C++《string的模拟实现》

article/2025/8/15 19:33:54

在之前的篇章C++《string》中我们已经了解了string中关于构造、容量、访问、修改操作等函数的功能，以及初步学习了这些函数的使用该如何使用。通过学习string内的各个函数后我们可以发现在解决一些要使用到字符串的环境下有了string内的这些函数操作能大大简化，在此当中最主要的是在进行插入、删除等操作时我们不用再显示的去对字符串的内存空间进行调整。那么在之前我们只是了解了string的该如何使用，接下来在本篇当中我们将试着模拟实现string，我们在学习了string的使用之后要模拟实现是为了能从更底层来了解string的各个功能时如何实现的，这会让加深对string的了解。接下来就开始本篇的学习吧！！！

注：在本篇string模拟实现当中是将需重点掌握的函数进行实现，而在日常较少使用的未进行实现 

1.实现各个函数之前的工作

在模拟实现string各个函数之前我们先要来解决在实现过程中文件应如何创建、模拟实现的string如何避免和std内的string冲突等问题

在此我们先来创建三个文件分别是string.h、string.cpp、test.cpp这三个文件将分别完成类的定义以及函数的声明、函数的定义、实现完函数之后的测试

接下来在来分析如何解决我们模拟实现的string和std这个命名空间内的string不冲突的问题

在此要解决这个问题就需要创建一个不与std名字相同的命名空间，这样只需要在调用string时指定为我们创建的命名空间就不会出现冲突的问题。因此在之后我们模拟实现string的各个函数都要放在我们创建的命名空间内。接下来模拟实现函数时还是采用声明和定义分离的方式，将声明放在string.h文件内，将定义放在string.cpp内，但如果实现的函数时较为短小的函数就直接将定义也放在string.h内让其变为内联函数

注：在创建命名空间时在string.cpp和头文件当中都定义一个相同名字的命名空间，这时因为在多个文件当中同名的命名空间会被认为是同一个namespace，不会出现冲突

解决了以上的问题接下来我们就先创建一个名字为zhz的命名空间，接下来在该命名空间内完成类string的定义

在string.h内定义string，在此我们先来定义string的成员变量，接下来再一一实现各成员函数

#include<iostream>
#include<string>
#include<assert.h>using namespace std;namespace zhz
{class string{public:
//成员函数private:
//成员变量char* _str = nullptr;size_t _size = 0;size_t _capacity = 0;};

由于string的底层是顺序表，因此在此string类的成员变量和我们之前实现顺序表一样定义三个变量，_str为指向内存空间的字符指针、_size为有效数据个数、_capacity为空间大小。并且在定义之后还给这几个变量加上缺省值

 

 2.构造函数与析构函数

 2.1构造函数

通过之前对string构造函数的学习我们知道string的构造函数提供了许多的接口，但在此模拟实现时我们只实现无参和参数为常量字符串的指针两个接口

接下来就来实现构造函数，在实现string无参的构造函数时你可能会直接想到和之前实现顺序表一样直接将指针置为nullptr，再将_size和_capacity赋值为0。但仔细思考就会发现这种做法是错误，这是由于在字符串和顺序表不同字符串的结尾都有\0,因此即使当字符串当中一个元素也没有时也要在末尾加上\0

先在srring.h完成函数的声明

string();

接下来在string.cpp内完成函数的定义

string::string():_str(new char[1]{'\0'}),_size(0),_capacity(0){}

在此你可能又会出现一个疑问是这里只申请一个char类型的空间那为什么在使用new时不直接使用new char('\0')，而是使用申请多个内存空间的方式new char[ ]{ }。要解决这个问题我们就不能只将视角放在无参的构造函数当中，我们要想到在之后实现的含参的构造等构造函数当中都是使用new来申请多个char类型的内存空间，那么这就使得在析构函数当中要使用到delete [ ]来释放，因此为了匹配析构函数当中的delete [ ]在构造函数当中也要使用new char[N]

完成了无参的构造函数接下来继续来实现参数为指向字符串指针的构造函数

先在srring.h完成函数的声明

string(const char* s );

接下来在string.cpp内完成函数的定义

我们之前在C语言学习了要求一个字符串的长度，使用strlen即可得到。那么你可能就会直接想到使用以下方式来实现

string::string(const char* s):_size(strlen(s)),_capacity(_size),_str(new char[_size+1])
{strcpy(_str,s);
}

以上看起来没什么问题但其实存在非常大的错误，在之前我们声明类string的成员变量顺序如下所示

提供之前构造函数初始化列表的学习我们知道初始化列表中变量的初始化顺序是按照各个变量的定义顺序先后初始化的，因此在以上按照这种方式实现的构造函数在初始化列表当中会先将变量_str初始化，但这时表示有效元素的变量_size还未完成初始化，这时_size的值就是随机值。

 

因此通过以上的分析就可以看出以上这种构造函数的写法是错误的，这时确实可以通过改变初始化列表内的初始化顺序来避免以上的问题，但是更优的解法是将_str和_capacity的初始化放在构造函数的函数体内实现

string::string(const char* s):_size(strlen(s))
{_str = new char[_size + 1];_capacity = _size;strcpy(_str, s);}

以上就完成了string的构造函数，以上我们是将无参和带参的两个函数分开定义这样会显得较为繁琐，那么是否能将以上两个函数合并为一个函数呢？
答案是当然可以，这就只需要在带参的函数在声明是加上缺少参数，这样就可以同时实现带参和不带参的string对象的初始化

先在srring.h完成函数的声明

string(const char* s = "");

注：在此使用""来作为参数的缺省值，就可以使得在用户未传参数时，参数值就为字符串"",这时字符串内就没有元素字符串长度就为0，当在末尾还是一个\0 

 接下来在string.cpp内完成函数的定义

string::string(const char* s):_size(strlen(s))
{_str = new char[_size + 1];_capacity = _size;strcpy(_str, s);
}

2.2析构函数

析构函数是要完成资源的清理，也就是要将我们之前申请的内存空间进行释放

先在srring.h完成函数的声明

~string();

 接下来在string.cpp内完成函数的定义

string::~string()
{delete[]_str;_str = nullptr;_size = _capacity = 0;
}

2.3拷贝构造函数

在此拷贝构造在string非常重要，因为在之后函数中的传值sting类型返回或者是传string类型参数都会调用拷贝构造，在此string当中有指向资源的指针因此当我们没有显示写拷贝构造时，编译器自主生成的拷贝构造完成的时浅拷贝，这就不符合我们的要求，因此只有显示的写拷贝构造才能实现深拷贝

先在srring.h完成函数的声明

string(const string& s);

  接下来在string.cpp内完成函数的定义

string::string(const string& s)
{_str = new char[s._capacity + 1];_size = s._size;_capacity = s._capacity;strcpy(_str, s._str);
}

3.赋值运算符重载

在string的赋值运算符重载和拷贝构造一样需要我们显示写以实现深拷贝

先在srring.h完成函数的声明

string& operator=(const string& str);

 接下来在string.cpp内完成函数的定义

string& string::operator=(const string& str)
{if (this != &str){delete[] _str;_str = new char[str._capacity+1];strcpy(_str, str._str);_size = str._size;_capacity = str._capacity;}return *this;
}

4. c_str

通过之前string的学习我们知道c_str是输出string对象当中的成员变量中的数组指针，在我们模拟实现当中也就是输出_str指针

在此由于该函数为短小函数就直接将该函数放在string.h内而不再使用声明和定义分离的方式

const char* c_str()const
{return _str;
}

 5.size与capacity

在此由于这两个函数都为短小函数就直接将该函数放在string.h内而不再使用声明和定义分离的方式

size_t size()const
{return _size;
}size_t capacity()const
{return _capacity;
}

6.下标+[ ]访问

在此对于string当中使用下标加[ ]来实现对string对象内的元素访问我们要实现非const版本和const版本，在对于非const对象访问时能读也能写，const对象访问时只能读。

要实现以上的要求接下来我们就要实现函数重载

先在srring.h完成函数的声明

char& operator[](size_t n);
const char& operator[](size_t n)const;

 接下来在string.cpp内完成函数的定义

char& string::operator[](size_t n)
{assert(n < _size);return _str[n];
}const char& string::operator[](size_t n)const
{assert(n < _size);return _str[n];
}

注：在此使用assert来检测下标位置n是否符合要求

7.迭代器

在此迭代器我们实现的是正向迭代器和const迭代器，而反向迭代器目前学习的知识还无法实现

在迭代器的模拟实现中我们使用的是将char*重命名为iterator，将const char*重命名为const_iterator

typedef char* iterator;
typedef const char* const_iterator;

接下来就来实现begin和end 

在此由于该迭代器地的函数都为短小函数就直接将该函数放在string.h内而不再使用声明和定义分离的方式

iterator begin()
{return _str;
}
const_iterator begin()const
{return _str;
}
iterator end()
{return _str + _size;
}
const_iterator end()const
{return _str + _size;
}

8.resize

通过之前string的学习我们知道resize的作用是将string对象的有效元素个数改为我们指定值，并且当指定值大于对象原空间时会进行扩容

先在srring.h完成函数的声明

void resize(size_t n ,char ch = '\0');

接下来在string.cpp内完成函数的定义

void string::resize(size_t n, char ch)
{if (n < _size){_str[n] = '\0';_size = n;}else{reserve(n);for(int i=_size; i<n ;i++){_str[i] = ch;}_size = n;_str[n] = '\0';}
}

9.reserve

通过之前string的学习我们知道reserve的作用是将string对象的内存空间大小改为指定大小，并且我们知道当使用reserve时若当前的值小于原开间的大小时对原空间大小不做处理，只有当指定的值大于原空间大小的值时才做处理。

先在srring.h完成函数的声明

void reserve(size_t n);

 接下来在string.cpp内完成函数的定义

void string::reserve(size_t n)
{if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[]_str;_str = tmp;_capacity = n;}
}

在以上实现reserve函数时先使用new是申请n+1大小的内存空间，之后再将原_str指向的内存空间的数据拷贝到新创建的内存空间内，之后再将原_str指针指向新的内存空间，最后将_capacity值置为n即可

10.push_back和append

通过之前string的学习我们知道push_back可以将一个字符尾插到字符串当中，而append能将一个字符串尾插到另一个字符串当中

先在srring.h完成函数的声明

void push_back(char ch);
void append(const char* str);

注：原append函数是实现了多个接口的， 在此我只是为了模拟实现，因此就只实现以上一个接口

 接下来在string.cpp内完成函数的定义

在实现尾插时实现的过程代码是很简单的和之前我们完成顺序表的尾插类似，但在插入之前我们先要将字符串的空间问题解决，也就是在当字符串在插入之前先判断是否要进行空间的扩容

在此由于push_back只插入一个字符那么对于是否要对空间进行调整的判断就较为简单，代码如下所示：

void string::push_back(char ch)
{if (_size == _capacity)//判断空间是否满了{reserve(_capacity == 0 ? 4 : 2 * _capacity);}_str[_size++] = ch;//尾插_str[_size] = '\0';
}

注：在此在将字符尾插到原字符串之后要在字符串下标_size位置值赋值为\0，这样才能让尾插之后也为字符串

完成了push_back的函数的实现接下来来实现append函数

在append函数当中由于插入的是字符串因此对于是否要对空间进行调整的判断就较为复杂，首先是要使用strlen得到要插入的字符串的长度，之后再判断将string对象中的字符串长度再加上要插入的字符串长度是否比原空间大小大；当比原空间大小小时就不需要扩容，比原空间大小大时就继续判断是否比原空间大小的两倍大，若比原空间大小的两倍大就将空间大小改变为原空间size+要插入的字符串的长度

void string::append(const char* str)
{size_t len = strlen(str);if (len + _size > _capacity){size_t newcapacity = 2 * _capacity;if (len + _size > newcapacity){newcapacity = _size + len;}reserve(newcapacity);}strcpy(_str + _size, str);_size += len;
}

11.+=运算符重载

在+=运算符的重载当中支持两个接口，分别是+=一个字符，+=一个字符串

先在srring.h完成函数的声明

string& operator+=(char ch);
string& operator+=(const char* str);

  接下来在string.cpp内完成函数的定义

在此在+=的实现当中直接调用之前实现的push_back和append即可

string& string::operator+=(char ch)
{push_back(ch);return *this;
}
string& string::operator+=(const char* str)
{append(str);return *this;
}

12.Insrt

通过之前string的学习我们了解了Insert是实现字符串任意位置的插入，在此该函数都支持了多个接口

在模拟实现当中我们只实现Insert的以下接口，在此先在string.h进行函数的声明

void Insert(size_t pos, char ch);
void Insert(size_t pos, const char* str);

 接下来在string.cpp内完成函数的定义

接下来先来分析Insert当中插入一个字符的接口该如何实现

在此来通过以上的示例来分析，在以上字符串当中如要在数组下标为8处插入字符X，也就是要在Wo和rld之间插入，那么就需要将从字符r开始的字符都向后移动一位，之后再将字符插入到数组下标为8处。

要实现以上的操作在此就定义一个变量end一开始为字符串末尾\0的数组下标，再定义一个变量pos为要插入字符的下标

之后从end位置开始将end位置的元素移动到end+1位置，再end--，之后一直重复该操作直到end与pos相等即停止。最后将要插入的字符插入到pos位置即完成字符串当中在pos位置插入字符

通过以上示例的分析就可以得出以下的代码

void string::Insert(size_t pos, char ch)
{assert(pos < _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : 2 * _capacity);}size_t end = _size;while (end >= pos){_str[end+1] = _str[end];end--;}_str[pos] = ch;_size++;
}

以上代码看起来似乎满足我们的要求，但实际上有一个非常大的问题没有考虑到，你发现了吗？

在此要注意的是由于数组下标没有负数因此一开始将pos类型定义为无符号整型size_t。之后将end的类型也定义为size_t这就使得当我们在下标为0位置插入字符时就会出现问题，问题是当最后将下标为0的数据赋值到下标为1处之后end--，在此end本应该为-1，之后就停止循环，但由于end为无符号整型再将0再减一之后就会变成整型的最大值，因此while循环会形成死循环。

通过以上的分析就可以看出以上代码是存在问题的，那么该如何修改呢？

这就要将变量类型修改成int，并且再while循环的判断部分要修改为end>=(int)pos，这是因为若不对pos进行强制类型转换，在该表达式会存在整型提升，会将有符号整型end提升为无符号整型，之后又会出现以上的问题 

void string::Insert(size_t pos, char ch)
{assert(pos < _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : 2 * _capacity);}int end = _size;while (end >= (int)pos){_str[end+1] = _str[end];end--;}_str[pos] = ch;_size++;
}

在以上我们使用的这种方法实现的过程中需要将end定义为int类型并且还要在循环时将pos强转为int，这个过程似乎有太多需要特别编写的地方，接下来就来实现一种更好的方法

在此也是先通过示例来讲解这种方法

还是在以上字符串当中如要在数组下标为8处插入字符X

在此还是先定义一个变量pos为要插入字符的下标，不同的是再再定义一个变量end一开始为字符串末尾\0的数组下标的下一位

之后从end位置开始将end-1位置的元素移动到end位置，再end--，之后一直重复该操作直到end-1与pos相等即停止。最后将要插入的字符插入到pos位置即完成字符串当中在pos位置插入字符

再以上使用这种方法就不存在最终end减一后为负数的情况了

以上方法实现的代码如下所示： 

void string::Insert(size_t pos, char ch)
{assert(pos < _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : 2 * _capacity);}size_t end = _size + 1;while (end > pos){_str[end] = _str[end - 1];end--;}_str[pos] = ch;_size++;
}

接下来我们继续实现Insert的另一个接口

在此来通过以上的示例来分析，在以上字符串当中如要在数组下标为8处插入字符串XXX，也就是要在Wo和rld之间插入，那么就需要将从字符r开始的字符都向后移动三位，之后再将字符串插入到数组下标为8处。

在此插入字符串和插入字符一样也有两种方式，以下是第一种实现方法
要实现以上的操作在此就定义一个变量end一开始为字符串末尾\0的数组下标，再定义一个变量pos为要插入字符的下标

之后从end位置开始将end位置的元素移动到end+3位置，再end--，之后一直重复该操作直到end与pos相等即停止。最后将要插入的字符插入到pos位置即完成字符串当中在pos位置插入字符

该方法实现的代码如下所示：

void string::Insert(size_t pos, const char* str)
{assert(pos < _size);size_t len = strlen(str);if (_size + len > _capacity){size_t newcapacity = 2 * _capacity;if (_size + len > newcapacity){newcapacity = _size + len;}reserve(newcapacity);}int end = _size ;while (end >= (int)pos){_str[end + len] = _str[end];end--;}for (size_t i = 0; i < len; i++){_str[pos + i] = str[i];}_size += len;
}

第二种实现方法

要实现以上的操作在此就定义一个变量end一开始为字符串末尾\0后一位的数组下标，再定义一个变量pos为要插入字符的下标

之后从end位置开始将end-3位置的元素移动到end位置，再end--，之后一直重复该操作直到end与pos+3相等即停止。最后将要插入的字符插入到pos位置即完成字符串当中在pos位置插入字符

该方法实现的代码如下所示：

void string::Insert(size_t pos, const char* str)
{assert(pos < _size);size_t len = strlen(str);if (_size + len > _capacity){size_t newcapacity = 2 * _capacity;if (_size + len > newcapacity){newcapacity = _size + len;}reserve(newcapacity);}size_t end = _size + len;while (end > pos + len - 1){_str[end] = _str[end - len];end--;}for (size_t i = 0; i < len; i++){_str[pos + i] = str[i];}_size += len;
}

13.Erase

通过之前string的学习我们了解了Erase是实现字符串任意位置的删除，在此该函数都支持了多个接口

 在模拟实现当中我们只实现Insert的以下接口，在此先在string.h进行函数的声明

void Erase(size_t pos = 0, size_t len = npos);

接下来在string.cpp内完成函数的定义

void string::Erase(size_t pos, size_t len)
{if (_size - pos <= len){_str[pos] = '\0';_size = pos;}else{size_t end = pos + len;while (end <= _size){_str[end - len] = _str[end];end++;}_size -= len;}}

14.find

通过之前sting的学习我们知道find是用于在一个字符串当中查找一个字符或者或者字符串，当字符或者字符串在原被查找的string对象当中存在时就返回首个字符的下标，了解了这些之后接下来就来模拟实现find函数

在此先在string.h进行函数的声明

size_t find(char ch, size_t pos = 0);
size_t find(const char* str, size_t pos = 0);

接下来在string.cpp内完成函数的定义

size_t string::find(char ch, size_t pos)
{assert(pos < _size);for (int i = pos; i < _size; i++){if (_str[i] == ch){return i;}}return npos;
}size_t string::find(const char* str, size_t pos)
{assert(pos < _size);char* p = strstr(_str + pos, str);if (p == nullptr){return npos;}return p - _str;
}

15.clear

在此在string中clear的功能是将srting对象的有效元素清除，那么模拟实现就很简单就只需要将string对象当中的_size变为0，并且再在_str数组下标为0处元素变为\0

由于该函数为短小函数，在此就将声明和定义都放在string.h内

void clear()
{_str[0] = '\0';_size = 0;
}

16.substr 

通过之前的学习我们知道在substr是来实现在str中从pos位置开始，截取n个字符，然后将其返回

在此先在string.h进行函数的声明

string substr(size_t pos = 0, size_t len = npos)const;

接下来在string.cpp内完成函数的定义

string string::substr(size_t pos, size_t len) const
{if (len > _size - pos){len = _size - pos;}string tmp;tmp.reserve(len);//提前扩容，避免多次扩容for (int i = 0; i < len; i++){tmp += _str[pos + i];}return tmp;}

16.关系运算符

在string当中通过了以下多个关系的判断的接口，在此在模拟实现当中我们只实现参数都为string的接口，当参数传的是字符指针时会进行隐式类型转换。并且要实现原string当中类似的函数就需要将这些关系运算符函数放在我们定义的类外

在此先在string.h进行函数的声明

bool operator== (const string& lhs, const string& rhs);
bool operator!= (const string& lhs, const string& rhs);
bool operator<= (const string& lhs, const string& rhs);
bool operator>= (const string& lhs, const string& rhs);
bool operator< (const string& lhs, const string& rhs);
bool operator> (const string& lhs, const string& rhs);

接下来在string.cpp内完成函数的定义

bool operator== (const string& lhs, const string& rhs)
{return strcmp(lhs.c_str(), rhs.c_str()) == 0;
}
bool operator!= (const string& lhs, const string& rhs)
{return !(lhs == rhs);
}
bool operator<= (const string& lhs, const string& rhs)
{return lhs == rhs || lhs < rhs;
}bool operator>= (const string& lhs, const string& rhs)
{return  !(lhs < rhs);
}
bool operator< (const string& lhs, const string& rhs)
{return strcmp(lhs.c_str(), rhs.c_str()) < 0;
}
bool operator> (const string& lhs, const string& rhs)
{return !(lhs <= rhs);
}

 

17.swap

在string当中提供了以上两个swap函数，在此你可能会有疑惑之前我们了解过在算法库当中还有一个swap函数那么为什么在string当中不直接使用算法库提供的这个swap而是在string当中再单独实现两个swap函数呢？

 

要解决以上的疑惑首先就要来了解算法库当中的swap底层是如何实现两个对象的交换的，提供算法库当中的swap文档就可以看出swap是通过再创建一个变量来实现两个对象的交换的

这个过程对于内置类型实现两个变量交换是不会使得程序的效率受到较大的影响，当在实现string对象数据的交换时就会给程序造成非常大的效率负担，这是为什么呢，接下来我们来仔细分析？

例如当我们将一个string对象s1与另一个string对象交换时就会进行以下的操作

1.首先是要在创建一个string类型的对象tmp将这两个对象其中一个的数据拷贝到tmp当中，这时就需要调用string的拷贝构造，这个过程需要申请新的内存空间
2.接下来就是s1对象和s2对象其中一个要将另一个的数据拷贝过来，之后再另一个对象还要将tmp的数据进行拷贝，再这过程中就会调用到string的赋值运算符重载，这个过程也是要申请新的内存空间的。最后再将s1、s2的原空间释放

通过以上的分析就可以看出再string对象的交换时如果我们调用的是算法库内的swap就需要新申请许多新的内存空间，这时在对象内的数据量较大时该swap的效率就比较低了

因此在string当中就通过了swap函数来避免调用string对象交换时调用算法库内swap造成效率的下降，在string当中的swap就不再是通过创建临时变量来实现对象数据的交换了而是直接将两个对象内的数组指针、有效元素个数、内存空间大小都交换

 那么你可能还会有疑问是为什么在string要提供两个参数不同的swap函数呢？

这时因为其中在string类域当中的swap函数的第一个参数是隐函的this指针，因此函数就无法实现和算法库一样的swap(s1,s2)形式来调用，而只能提供s1.swap(s2)来实现，因此在string当中在string的类域外再提供和算法库swap调用形式的函数

在了解了string当中的swap函数之后接下来就来模拟实现该函数

在此先在string.h进行函数的声明

void swap(string& str);//在string类域内的swap函数void swap(string& str1, string& str2);//在string类域外的swap函数

 接下来在string.cpp内完成函数的定义

void string::swap(string& str)
{std::swap(_str, str._str);std::swap(_size, str._size);std::swap(_capacity, str._capacity);
}void swap(string& str1, string& str2)
{str1.swap(str2);
}

 

18.流插入与流输出

在string当中我们了解了在string有流插入函数operator<<和流输出函数operator>>、getline。接下来我们就来模拟实现这三个函数

在此先在string.h进行函数的声明

ostream& operator<<(ostream& os, const string& str);
istream& operator>>(istream& is,  string& str);
istream& getline(istream& is, string& str, char delim ='\n');

 接下来在string.cpp内完成函数的定义

ostream& operator<<(ostream& os, const string& str)
{for (int i = 0; i < str.size(); i++){os << str[i];}return os;
}istream& operator>>(istream& is, string& str)
{
//将原对象数据清空str.clear();
//创建一个数组先将用户输入的的数据保存在该数组内，从而避免原string对象内存空间频繁扩容char buffer[256];char ch;
//使用get()能实现一个一个字符的读取并且不会跳过空白字符ch = is.get();int i = 0;while (ch != ' ' && ch != '\n'){buffer[i++] = ch;
//当buffer数组满了就将数据输入到string对象if (i == 255){buffer[i] = '\0';str += buffer;i = 0;}ch = is.get();}
//当buffer未满时当get()读取到空格或者换行时也将数组buffer的数据输入到string对象内if (i > 0){buffer[i] = '\0';str += buffer;}return is;}istream& getline(istream& is, string& str, char delim)
{
//将原对象数据清空str.clear();char ch;
//使用get()能实现一个一个字符的读取并且不会跳过空白字符ch = is.get();
//创建一个数组先将用户输入的的数据保存在该数组内，从而避免原string对象内存空间频繁扩容char buffer[256];int i = 0;while (ch != delim){buffer[i++] = ch;
//当buffer数组满了就将数据输入到string对象if (i == 255){buffer[i] = '\0';str += buffer;i = 0;}ch = is.get();}}
//当buffer未满时当get()读取到指定字符delim时也将数组buffer的数据输入到string对象内if (i > 0){buffer[i] = '\0';str += buffer;}return is;
}

19.拷贝构造和赋值运算符重载现代写法

在以上我们实现的拷贝构造和赋值运算符的重载申请空间的数据的拷贝都是我们自己来实现的，其实这两个函数还有一种现代的写法更加的简洁

以下是这两个函数现代写法的代码

//赋值运算符的重载现代写法
string& string::operator=(string str)
{swap(str);//swap(this,str)return *this;
}//拷贝构造现代写法
string::string(const string& s)
{string tmp(s._str);swap(tmp);//this.swap(str)
}

 

20.写时拷贝(了解)

写时拷贝就是一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。
引用计数：用来记录资源使用者的个数。在构造时，将资源的计数给成1，每增加一个对象使用该
资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，
如果计数为1，说明该对象时资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有
其他对象在使用该资源

想详细了解的可以看以下大佬的文章

C++ STL string的Copy-On-Write技术 | 酷 壳 - CoolShell

C++的std::string的“读时也拷贝”技术！ | 酷 壳 - CoolShell

 

string模拟实现完整代码

string.h

#define _CRT_SECURE_NO_WARNINGS
#pragma once
#include<iostream>
#include<string>
#include<assert.h>using namespace std;namespace zhz
{class string{public:typedef char* iterator;typedef const char* const_iterator;//string();string(const char* s = "");string(const string& s);~string();//string& operator=(const string& str);string& operator=( string str);size_t size()const{return _size;}size_t capacity()const{return _capacity;}const char* c_str()const{return _str;}char& operator[](size_t n);const char& operator[](size_t n)const;void reserve(size_t n);void resize(size_t n ,char ch = '\0');void push_back(char ch);void append(const char* str);string& operator+=(char ch);string& operator+=(const char* str);void Insert(size_t pos, char ch);void Insert(size_t pos, const char* str);void Erase(size_t pos = 0, size_t len = npos);size_t find(char ch, size_t pos = 0);size_t find(const char* str, size_t pos = 0);string substr(size_t pos = 0, size_t len = npos)const;void swap(string& str);void clear(){_str[0] = '\0';_size = 0;}iterator begin(){return _str;}const_iterator begin()const{return _str;}iterator end(){return _str + _size;}const_iterator end()const{return _str + _size;}private:char* _str = nullptr;size_t _size = 0;size_t _capacity = 0;public:static  size_t npos;};void swap(string& str1, string& str2);bool operator== (const string& lhs, const string& rhs);bool operator!= (const string& lhs, const string& rhs);bool operator<= (const string& lhs, const string& rhs);bool operator>= (const string& lhs, const string& rhs);bool operator< (const string& lhs, const string& rhs);bool operator> (const string& lhs, const string& rhs);ostream& operator<<(ostream& os, const string& str);istream& operator>>(istream& is,  string& str);istream& getline(istream& is, string& str, char delim ='\n');
}

string.cpp

#include"string.h"namespace zhz
{/*string::string():_str(new char[1]{'\0'}),_size(0),_capacity(0){}*/size_t string::npos = -1;string::string(const char* s):_size(strlen(s)){_str = new char[_size + 1];_capacity = _size;strcpy(_str, s);}/*string::string(const string& s){_str = new char[s._capacity + 1];_size = s._size;_capacity = s._capacity;strcpy(_str, s._str);}*///拷贝构造现代写法string::string(const string& s){string tmp(s._str);swap(tmp);}string::~string(){delete[]_str;_str = nullptr;_size = _capacity = 0;}char& string::operator[](size_t n){assert(n < _size);return _str[n];}const char& string::operator[](size_t n)const{assert(n < _size);return _str[n];}void string::reserve(size_t n){if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[]_str;_str = tmp;_capacity = n;}}void string::resize(size_t n, char ch){if (n < _size){_str[n] = '\0';_size = n;}else{reserve(n);for(int i=_size; i<n ;i++){_str[i] = ch;}_size = n;_str[n] = '\0';}}void string::push_back(char ch){if (_size == _capacity){reserve(_capacity == 0 ? 4 : 2 * _capacity);}_str[_size++] = ch;_str[_size] = '\0';}void string::append(const char* str){size_t len = strlen(str);if (len + _size > _capacity){size_t newcapacity = 2 * _capacity;if (len + _size > newcapacity){newcapacity = _size + len;}reserve(newcapacity);}strcpy(_str + _size, str);_size += len;}string& string::operator+=(char ch){push_back(ch);return *this;}string& string::operator+=(const char* str){append(str);return *this;}/*string& string::operator=(const string& str){if (this != &str){delete[] _str;_str = new char[str._capacity+1];strcpy(_str, str._str);_size = str._size;_capacity = str._capacity;}return *this;}*///赋值运算符的重载现代写法string& string::operator=(string str){swap(str);return *this;}/*void string::Insert(size_t pos, char ch){assert(pos < _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : 2 * _capacity);}int end = _size;while (end >= (int)pos){_str[end+1] = _str[end];end--;}_str[pos] = ch;_size++;}*/void string::Insert(size_t pos, char ch){assert(pos < _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : 2 * _capacity);}size_t end = _size + 1;while (end > pos){_str[end] = _str[end - 1];end--;}_str[pos] = ch;_size++;}/*void string::Insert(size_t pos, const char* str){assert(pos < _size);size_t len = strlen(str);if (_size + len > _capacity){size_t newcapacity = 2 * _capacity;if (_size + len > newcapacity){newcapacity = _size + len;}reserve(newcapacity);}int end = _size ;while (end >= (int)pos){_str[end + len] = _str[end];end--;}for (size_t i = 0; i < len; i++){_str[pos + i] = str[i];}_size += len;}*/void string::Insert(size_t pos, const char* str){assert(pos < _size);size_t len = strlen(str);if (_size + len > _capacity){size_t newcapacity = 2 * _capacity;if (_size + len > newcapacity){newcapacity = _size + len;}reserve(newcapacity);}size_t end = _size + len;while (end > pos + len - 1){_str[end] = _str[end - len];end--;}for (size_t i = 0; i < len; i++){_str[pos + i] = str[i];}_size += len;}void string::Erase(size_t pos, size_t len){if (_size - pos <= len){_str[pos] = '\0';_size = pos;}else{size_t end = pos + len;while (end <= _size){_str[end - len] = _str[end];end++;}_size -= len;}}size_t string::find(char ch, size_t pos){assert(pos < _size);for (int i = pos; i < _size; i++){if (_str[i] == ch){return i;}}return npos;}size_t string::find(const char* str, size_t pos){assert(pos < _size);char* p = strstr(_str + pos, str);if (p == nullptr){return npos;}return p - _str;}string string::substr(size_t pos, size_t len) const{if (len > _size - pos){len = _size - pos;}string tmp;tmp.reserve(len);//提前扩容，避免多次扩容for (int i = 0; i < len; i++){tmp += _str[pos + i];}return tmp;}void string::swap(string& str){std::swap(_str, str._str);std::swap(_size, str._size);std::swap(_capacity, str._capacity);}void swap(string& str1, string& str2){str1.swap(str2);}bool operator== (const string& lhs, const string& rhs){return strcmp(lhs.c_str(), rhs.c_str()) == 0;}bool operator!= (const string& lhs, const string& rhs){return !(lhs == rhs);}bool operator<= (const string& lhs, const string& rhs){return lhs == rhs || lhs < rhs;}bool operator>= (const string& lhs, const string& rhs){return  !(lhs < rhs);}bool operator< (const string& lhs, const string& rhs){return strcmp(lhs.c_str(), rhs.c_str()) < 0;}bool operator> (const string& lhs, const string& rhs){return !(lhs <= rhs);}ostream& operator<<(ostream& os, const string& str){for (int i = 0; i < str.size(); i++){os << str[i];}return os;}istream& operator>>(istream& is, string& str){str.clear();char buffer[256];char ch;ch = is.get();int i = 0;while (ch != ' ' && ch != '\n'){buffer[i++] = ch;if (i == 255){buffer[i] = '\0';str += buffer;i = 0;}ch = is.get();}if (i > 0){buffer[i] = '\0';str += buffer;}return is;}istream& getline(istream& is, string& str, char delim){str.clear();char ch;ch = is.get();char buffer[256];int i = 0;while (ch != delim){buffer[i++] = ch;if (i == 255){buffer[i] = '\0';str += buffer;i = 0;}ch = is.get();}if (i > 0){buffer[i] = '\0';str += buffer;}return is;}}

 


http://www.hkcw.cn/article/dmhWZEvTnl.shtml

相关文章

2025华为OD机试真题最新题库 (B+C+D+E+2025A+2025B卷) + 在线OJ在线刷题使用（C++、Java、Python C语言 JS合集）（正在更新2025B卷，目前已收录710道）

2025华为OD机试真题最新题库 (B+C+D+E+2025A+2025B卷) + 在线OJ在线刷题使用（C++、Java、Python C语言 JS合集）（正在更新2025B卷，目前已收录710道）

2025年&#xff0c;已经开始使用AB卷题库&#xff0c;题目和往期一样&#xff0c;旧题加新题的组合&#xff0c;有题目第一时间更新&#xff0c;大家可以跟着继续学习&#xff0c;目前使用复用题较多&#xff0c;可在OJ上直接找到对应的AB卷学习&#xff0c;可以放心学习&#…
阅读更多...
基于Java的不固定长度字符集在指定宽度和自适应模型下图片绘制生成实战

基于Java的不固定长度字符集在指定宽度和自适应模型下图片绘制生成实战

目录 前言 一、需求介绍 1、指定宽度生成 2、指定列自适应生成 二、Java生成实现 1、公共方法 2、指定宽度生成 3、指定列自适应生成 三、总结 前言 在当今数字化与信息化飞速发展的时代&#xff0c;图像的生成与处理技术正日益成为众多领域关注的焦点。从创意设计到数…
阅读更多...
【C++】 —— 笔试刷题day_29

【C++】 —— 笔试刷题day_29

一、排序子序列 题目解析 一个数组的连续子序列&#xff0c;如果这个子序列是非递增或者非递减的&#xff1b;这个连续的子序列就是排序子序列。 现在给定一个数组&#xff0c;然后然我们判断这个子序列可以划分成多少个排序子序列。 例如&#xff1a;1 2 3 2 2 1 可以划分成 …
阅读更多...
企业微信自建应用实现接收消息和发送消息功能（python）

企业微信自建应用实现接收消息和发送消息功能（python）

# 这一周我不断的琢磨企业微信自建应用并且实现了自建应用的消息接收和发送功能 1.笔记&#xff0c;记录 第一步&#xff1a;打开企业微信后台 https://work.weixin.qq.com 1.1 如果没有企业可以在这里申请&#xff0c;如果有可以直接扫码登录 1.2 打开后台-应用管理-自建应用…
阅读更多...
【Rust多线程】Rust并发编程，如何轻松实现无畏并发

【Rust多线程】Rust并发编程，如何轻松实现无畏并发

✨✨ 欢迎大家来到景天科技苑✨✨ &#x1f388;&#x1f388; 养成好习惯&#xff0c;先赞后看哦~&#x1f388;&#x1f388; &#x1f3c6; 作者简介&#xff1a;景天科技苑 &#x1f3c6;《头衔》&#xff1a;大厂架构师&#xff0c;华为云开发者社区专家博主&#xff0c;…
阅读更多...
2025粤港澳信息学创新大赛备考指南Python，C++，图形化历年真题训练题

2025粤港澳信息学创新大赛备考指南Python，C++，图形化历年真题训练题

官方指导文件 训练题目 ZCM5:Python小学组-单项选择题 1.小明安装软件的时候发现软件要求Windows环境&#xff0c;这 个要求限制的是? A.操作系统 B.计算机内存 C.网络设置 D.程序语言 答案‌&#xff1a;A. 操作系统 解析‌&#xff1a;软件运行的环境通常指的是操作系统&am…
阅读更多...
【C++指南】“单身狗问题”——只出现一次的数字 系列问题

【C++指南】“单身狗问题”——只出现一次的数字 系列问题

. &#x1f493; 博客主页&#xff1a;倔强的石头的CSDN主页 &#x1f4dd;Gitee主页&#xff1a;倔强的石头的gitee主页 ⏩ 文章专栏&#xff1a;《C指南》 期待您的关注 文章目录 引言一、只出现一次的数字&#xff08;一&#xff09;简单题目描述解题思路代码实现及解释 二…
阅读更多...
优化 InfluxDB 写入性能：高效批处理策略实战指南

优化 InfluxDB 写入性能：高效批处理策略实战指南

在处理高吞吐量时序数据时&#xff0c;合理运用批处理&#xff08;Batching&#xff09;策略是提升 InfluxDB 写入性能的关键。本文介绍 时间驱动、大小驱动和混合批处理策略&#xff0c;并通过 Python 代码示例展示如何优化数据写入&#xff0c;平衡 延迟与吞吐量。同时&#…
阅读更多...
RedwoodJS：乱拳打倒老师傅 NextJS！

RedwoodJS：乱拳打倒老师傅 NextJS！

RedwoodJS 是一个全栈的 JavaScript/TypeScript 框架&#xff0c;其作用是帮助开发者高效地构建现代化的 Web 应用。它将前端、后端和数据库集成在一起&#xff0c;并使用一种“JAMstack”架构&#xff08;JavaScript、API 和 Markup&#xff09;来构建可扩展的应用程序。 Star…
阅读更多...
【C++】 —— 笔试刷题day_18

【C++】 —— 笔试刷题day_18

一、压缩字符串(一) 题目解析 题目给定一个字符str&#xff0c;让我们将这个字符串进行压缩&#xff1b; **压缩规则&#xff1a;**出现多次的字符压缩成字符数字&#xff1b;例如aaa压缩成a3。如果字符值出现一次&#xff0c;1不用写。 算法思路 这道题总的来说就非常简单了…
阅读更多...
谷歌浏览器如何禁用javaScript

谷歌浏览器如何禁用javaScript

通过禁用js&#xff0c;可以访问一些设置权限的内容。 Chrome 地址栏输入 chrome://settings/content 回车。 找到 JavaScript 选项。 切换为 不允许网站使用 JavaScript。 地址栏输入&#xff1a; chrome://settings/content/javascript?searchJavaScript Firefox 地址栏输入…
阅读更多...
Java从入门到“放弃”（精通）之旅——类和对象全面解析⑦

Java从入门到“放弃”（精通）之旅——类和对象全面解析⑦

Java从入门到“放弃”&#xff08;精通&#xff09;之旅&#x1f680;——类和对象全面解析⑦ 一、面向对象初探 1.1 什么是面向对象&#xff1f; Java是一门纯面向对象的语言(OOP)&#xff0c;在面向对象的世界里&#xff0c;一切皆为对象。面向对象是解决问题的一种思想&am…
阅读更多...
【Golang】第七弹----map

【Golang】第七弹----map

笔上得来终觉浅,绝知此事要躬行 &#x1f525; 个人主页&#xff1a;星云爱编程 &#x1f525; 所属专栏&#xff1a;Golang &#x1f337;追光的人&#xff0c;终会万丈光芒 &#x1f389;欢迎大家点赞&#x1f44d;评论&#x1f4dd;收藏⭐文章 1基本介绍 Go语言中的 map …
阅读更多...
C/C++程序员为什么要了解汇编？了解汇编有哪些好处？如何学习汇编？

C/C++程序员为什么要了解汇编？了解汇编有哪些好处？如何学习汇编？

目录 1、概述 2、从汇编的角度去理解问题的若干实例说明 2.1、使用空指针去访问类的数据成员或调用类的虚函数为什么会引发崩溃？ 2.2、从汇编代码的角度去理解多线程的执行细节，去理解多线程在访问共享资源时为什么要加锁 2.3、使用Windbg静态分析dump时先从崩溃的那条汇…
阅读更多...
基于谐波线性化方法的跟网型GFL并网变流器/VSC宽频序阻抗建模及扫频（Matlab/Simulink平台）及文献复现

基于谐波线性化方法的跟网型GFL并网变流器/VSC宽频序阻抗建模及扫频（Matlab/Simulink平台）及文献复现

目录 1、课程及模型介绍 2、谐波线性化方法介绍 3、跟网型及构网型并网变流器的特点 4、跟网型变流器/VSC拓扑及控制结构 5、不同坐标系下VSC序阻抗建模推导过程 5.1 abc三相坐标系下的VSC序阻抗建模 5.2 d-q旋转坐标系下的VSC序阻抗建模 5.2.1 Park变换及频率偏移效应…
阅读更多...
C++“STL之String”

C++“STL之String”

​ 🌹个人主页🌹：喜欢草莓熊的bear 🌹专栏🌹：C++入门 目录 ​编辑 前言 一、STL简介 1.1 STL是什么？ 1.2 STL的版本（这个不是很重要了解即可） 1.3 STL的六大组件 二、 String类 2.1为什么要学习String类？ 2.1.1 C语言中的字符串…
阅读更多...
C++之多态

C++之多态

开始新的征程啦———多态&#xff0c;它也是C的三大特性之一。 文章目录 一、多态的概念二、多态的定义和实现2.1多态的定义2.2 实现动态多态所需要的条件&#xff08;2个&#xff09;2.3 虚函数的定义2.4 虚函数的重写/覆盖2.5 虚函数重写中的问题2.5.1 协变2.5.2 析构函数的…
阅读更多...
【第十六届蓝桥杯省赛】比赛心得与经验分享（PythonA 组）

【第十六届蓝桥杯省赛】比赛心得与经验分享（PythonA 组）

文章目录 一、我的成绩二、我的备赛经历三、如何备赛&#xff08;个人观点&#xff09;1. 基础语法2. 数据结构3. 算法4. 数学 四、做题技巧与注意事项五、我的题解试题A 偏蓝 &#x1f3c6;100%试题B IPV6 &#x1f3c6;0%试题C 2025图形 &#x1f3c6;100%试题D 最大数字 &am…
阅读更多...
21天Python计划：零障碍学语法（更新完毕）

21天Python计划：零障碍学语法（更新完毕）

文章目录 前言Python 部分MySQL 部分目录结语资料截图 前言 此技术博客专栏围绕 Python 编程和 MySQL 数据库展开了系统且循序渐进的知识讲解&#xff0c;共包含 21 篇文章。 Python 部分 从基础入门逐步深入到高级应用。首先介绍了 Python 的下载和开发工具&#xff0c;为后续…
阅读更多...
JavaScript--js基础(详细 全面)

JavaScript--js基础(详细 全面)

目录 前言: JavaScript 是什么&#xff1f;JavaScript 简介 1.JavaScript历史 2.JavaScript 具有以下特点 第一个JavaScript程序 1.在脚本文件中编写JavaScript代码 2.JavaScript代码执行顺序 基本语法 1.变量 2.数据类型 3.算术运算符 4.赋值运算 5.字符串运算符 6…
阅读更多...
推荐文章

Copyright @ 2022~2023