Welcome to 9ilk's Code World

       

(๑•́ ₃ •̀๑) 个人主页:        9ilk

(๑•́ ₃ •̀๑) 文章专栏：     与C++的邂逅   

---

本篇博客我们将来了解string容器本身以及接口的使用。

---

string是串，本质是一个字符数组，可以对其进行增删查改。

🏠 string构造

<code>//常用

string s1;

string s2("hello world");

string s3(s2);

//不常用

string s4(s2,3,5); // string (const string& str, size_t pos, size_t len = npos)

string s5(s2,3);

string s6(s2,3,30);

string s7("hello world",5) //string (const char* s, size_t n)

string s8(10,'x'); //string (size_t n, char c);

对于string的构造，我们常用的是它的无参构造，拷贝构造等。注意：在库中pos通常代表位置，n代表的是个数。

npos

由库中文档说明,我们可以知道 :

1. npos是string里的一个const静态成员变量,类型是size_t,缺省值给的是-1(整形最大).

2. 当使用substring的这个构造时,从str的pos位置开始拷贝构造,如果要构造的长度len大于后面的长度,则有多少拷贝多少直到拷贝到结尾 .

3. 缺省参数npos是整形最大值,一定大于后面的长度,不传第三个参数默认拷贝到结尾.

<code>string s2("hello world");

// string (const string& str, size_t pos, size_t len = npos)

string s4(s2,3,5); //拷贝5个字符

string s5(s2,3); //拷贝到结尾

string s6(s2,3,30);//拷贝到结尾

隐式类型转换在构造中的应用

string s1("hello world");

//隐式类型转换

string s2 = "hello world";

const string& s3 = "hello world";

//以及后面其他接口也可以使用...

push_back("hello world");

说明 :

1. 对于s2是先调用常量字符串的构造生成一个临时对象,再调用拷贝构造将临时对象拷贝给s2.

2. 对于s3,它引用的是临时对象,而临时对象具有"常性",因此需要是const引用.

🏠 元素访问方式

📌 operator[ ]

char& operator[] (size_t pos);

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

引用返回

int main()

{

string s = "hello";

for (size_t i = 0; i < s.size(); i++)

{

cout << s.operator[](i) << " "; //显式[]+下标访问对象元素

cout << s[i] << " ";//隐式[]+下标访问对象元素

}

for (size_t i = 0; i < s.size(); i++)

{

s[i]++; //修改访问元素内容

}

return 0;

}

由于string类重载了[ ]运算符,所以我们可以直接利用[ ] + 下标访问对象中的元素;同时由于是引用返回,所以我们可以通过[ ] + 下标修改对应位置的元素内容,也就是可读可写.

class string

{

/...

private:

char* _str;

size_t _size;

int _capacity;

}

char& operator[](size_t pos)

{

assert(i < _size);

return _str[i];

}

string类一般是动态开辟内存来储存字符元素,所以实现operator[ ]一般返回的是在堆上的空间,因此我们不用担心传引用返回时返回的是一个局部对象.

传引用返回优势 : 

1. 能修改返回对象.

2. 减少拷贝.

string类重载的[]运算符还会执行严格的越界检查,只要下标超过size或小于0就报错.opertaor[ ]有两个版本,一个是非const,返回对象可修改,是典型的可读可写;另一个是const版本,返回对象内容不可修改.

const string s2("hello");

s2[0] = 'x'; //不可修改 调用const版本的operator[]

string s1("hello");

s1[0] = 'x';//调用非const版本的opeator[]

1. const版本重载的[ ]主要是给const对象用的,毕竟const对象无法调用非const版本,这是权限的扩大.

2. 对于const和非const对象其实都能调用const版本的重载,但却重载出两个版本,这是因为各自有不同的需求(比如只有一个const版本的operator[ ],对于普通string对象就不能修改了,不符合我们的要求,如果重载了两个版本则调用更匹配的,普通对象调用普通版本,const对象调用const版本).

3.具体实践中重载[]操作符看具体需求.

📌 迭代器

迭代器目前我们可以理解为具有和指针类似行为的东西,但实际上不一定是指针.

string::iterator it = s.begin();

while (it != s.end())

{

cout << *it << endl; //类似指针解引用

++it;//类似指针++

}

auto it = s.begin();

迭代器访问元素是所有容器(除stack,queue外)通用的访问方式,他们通用的将迭代器命名为iterator,头元素位置的迭代器和尾元素位置的迭代器都命名为begin和end,它们都是定义在类域里的成员函数.

注 : C++11之后，直接使用auto定义迭代器，让编译器推到迭代器的类型.

for (auto ch : s)

cout << ch << endl;

C++11之后我们更喜欢用范围for来访问string类元素,它底层也是利用的迭代器.

begin与end

对于begin返回的是开始位置,对于end返回的是最后一个字符的下一个位置,在string类中大概就是\0的位置.

迭代器的版本

<code>const string s1("hello");

string::const_iterator it1 = s1.begin();

while (it1 != s1.end())

{

cout << *it1 << endl;//无法修改

}

迭代器分为iterator(可读可写)和const_iterator(只读),对于const对象匹配的是返回const_iterator的begin().下面我们来区分const iterator , iterator 和 const_iterator.

类型	特点	类比指针
iterator	可读可写	int* p1
const_iterator	只读 迭代器指向数据不能写	const int* p2
const iterator	迭代器本身不能写	int* const p3

反向迭代器

<code>string::reverse_iterator it2 = s1.rbegin();

while (it2 != s1.rend())

{

*it2 += 3;

++it2;

}

反向迭代器是从后往前遍历,rbgein就是返回的原来正向最后一个元素位置(\0前面),rend返回的是原来正向第一个元素的前一个位置.

注 : string类通过运算符重载改变了反向迭代器++和--的行为,底层是封装的正向迭代器.

总结 : 迭代器一共有四种:1. iterator的const和非const版本 以及 reverse_iterator的const和非const版本.

注 : 库里面其实还有cbegin和cend,他们其实就是类似iterator的const版本.

📌 at

<code>string s1("hello");

try

{

s1[10];

}

catch (const exception& e)

{

cout << e.what() << endl;

}

string s("hello world");

for (size_t i = 0; i < s.size(); i++)

{

//at(pos)访问pos位置的元素

cout << s.at(i);

}

cout << endl;

for (size_t i = 0; i < s.size(); i++)

{

//at(pos)访问pos位置的元素，并对其进行修改

s.at(i) = 'x';

}

cout << s << endl; //xxxx

at是访问pos位置的字符,它也是引用返回,可读可写;与operator[ ]不同的是,operator[ ]对于下标是暴力检查,而at是抛异常,两者底层处理越界的方式不同.

总结:

string类元素遍历方式主要有4种:

1. [ ] + 下标

2. 使用at访问对象中的元素

3. 迭代器遍历

4.范围for

我们实践中主要用的是[]以及范围for.

🏠 修改

📌 尾部插入和尾部删除

📒 尾部插入

push_back()

void push_back (char c);

//应用

string s("hello");

s1.push_back('x');

我们可以使用push_back来尾部插入字符。

append()

string& append (const string& str);

string& append (const char* s);

string& append (size_t n, char c);

//应用

string s1("hello");

string s2(" world");

//append(string)完成两个string对象的拼接

s1.append(s2); //hello world

//append(str)完成string对象和字符串str的拼接

s1.append(" C++"); //hello world C++

//append(n, char)将n个字符char拼接到string对象后面

s1.append(3, '!'); //hello world C++!!!

cout << s1 << endl; //hello world C++!!!

我们可以使用append来实现尾部插入string对象/字符串/多个相同字符；这里也体现了vector与string的不同：vector<char>一次只能进一个char字符，而string对象一次可能进一个串。

operator +=

string类重载的+=可以+=一个字符/串/string对象，我们在实践中更多使用+=来尾部插入。

string s1("hello");

string s2(" world");

s1 += s2; //+=string

s1 += "C++" ; //+=字符串

s1 += '!'; //+=字符

📒 尾部删除

void pop_back();

string str ("hello world!");

str.pop_back();

cout << str << '\n'; //hello world

我们可以用pop_back来删除string对象的尾部字符。

📌 insert和erase

insert

string& insert (size_t pos, const string& str);

string& insert (size_t pos, const char* s);

iterator insert (iterator p, char c);

template <class InputIterator>

void insert (iterator p, InputIterator first, InputIterator last);

insert可以帮助我们在pos位置(下标/迭代器)插入字符，可以插入一个string对象/字符串/字符。注意是在pos位置插入！

string s("C"); //C

//insert(pos, str)在pos位置插入字符串str

s.insert(1, "H"); //CH

//insert(pos, string)在pos位置插入string对象

string t("I");

s.insert(2, t); //CHI

//insert(pos, char)在pos位置插入字符char

s.insert(s.end(), 'N'); //CHIN

//nsert (iterator p, InputIterator first, InputIterator last)

//在p位置插入另一个迭代区间

string h("A");

s.insert(s.end(),h.begin(),h.end());

cout << s << endl; //CHINA

注 ： 

1. 使用insert时，我们要注意传入区间和下标的合法性。

2. 一次insert的时间复杂度是O(N),一段程序中不断对string对象调用insert会有较大的时间消耗，因此在实践中我们要慎用。

3. insert其实可以复用来实现尾插头插。

erase

string& erase (size_t pos = 0, size_t len = npos);

iterator erase (iterator p);

iterator erase (iterator first, iterator last);

erase可以帮助我们实现在指定位置删除后面指定长度len，同样地，如果不传npos或传的len大于剩下的字符串长度，则有多少删多少。

string s("hello");

s.erase(0, 1);

cout << s << endl; //输出ello

s.erase(0, 20);

cout << s << endl;//输出空串

注 ： erase也是一样要慎用效率不高，也是O(N)

📌 assign

string& assign (const string& str);

string& assign (const char* s);

//应用

//const char* str

string s1("hello world");

s1.assign("yes");

cout << s1 << endl; //输出yes

//string

string s2("ha");

s1.assign(s2);

cout << s1<< endl; //输出ha

assign其实是变相的赋值，把原来的内容清空再赋值成新的内容。

📌 replace

string& replace (size_t pos, size_t len, const string& str);

string& replace (size_t pos, size_t len, const char* s);

string& replace (size_t pos, size_t len, size_t n, char c);

replace接口的作用是把原串的某一段内容替换位为字符/字符串。

//string& replace (size_t pos, size_t len, const string& str);

string s("hellea");

s.replace(4,1,"oworld");// helloworlda

cout << s << endl;

// string& replace (size_t pos, size_t len, size_t n, char c);

s = "hellea";

s.replace(4,1,2,'o');

cout << s << endl;//hellooa

注 ： 

1. len表示的是从pos位置开始要替换的字符个数。

2. replace如果替换字符多的话效率不高，也需要慎用。

string s("hello world hello bit");

for (int i= 0; i < s.size() ;)

{

if (s[i] == '.')

{

s.replace(i, 1, "%20");

i += 3;

}

else

i++;

}

我们可以用replace实现替换空格，但是这样效率不高，我们可以利用一个新的string对象提高效率,这样不用挪数据到新串里。

string s("hello world hello bit");

string s1;//空串

for(auto ch : s)

{

if(ch != ' ')

s1 += ch;

else

s1 += "%20";

}

📌 operator + 

string类中对+运算符进行了重载，重载后的+运算符支持以下几种类型的操作：

1.string类 + string类

2.string类 + 字符串

3.字符串 + string类

4.string类 + 字符

5.字符 + string类

它们相加后均返回一个string类对象。

string s;

string s1("super");

string s2("man");

char str[] = "woman";

char ch = '!';

//string类 + string类

s = s1 + s2;

cout << s << endl; //superman

//string类 + 字符串

s = s1 + str;

cout << s << endl; //superwoman

//字符串 + string类

s = str + s1;

cout << s << endl; //womansuper

//string类 + 字符

s = s1 + ch;

cout << s << endl; //super!

//字符 + string类

s = ch + s1;

cout << s << endl; //!super

注 ：operator+重载，参数必须要有一个自定义类型，因此不能字符串+字符串。

🏠 容量

📌 size()与length()

string s1 = "hello";

cout << s1.size() << endl; //输出5

cout << s1.length() << endl;

说明 :

1. 对于size和length都是求字符串的长度.length是主要针对串这个容器而设计的,而size是面对大多数容器设计的表示"容器元素个数"的接口.

2. 对于size和length,两个算出的字符串长度都是不算'\0'的 ! 

📌 capacity

size_t capacity() const;

使用capacity函数获取当前对象所分配的存储空间的大小。

string s("CSDN");

cout << s.capacity() << endl; //15

关于扩容方式的探讨：

void TestPushBack()

{

string s;

size_t sz = s.capacity();

cout << "making s grow:\n";

for (int i = 0; i < 100; ++i)

{

s.push_back('c');

if (sz != s.capacity())

{

sz = s.capacity();

cout << "capacity changed: " << sz << '\n';

}

}

}

vs2019环境输出结果：

capacity changed:15

making s grow:

capacity changed:31

capacity changed:47

capacity changed:70

capacity changed:105

capacity changed:157

capacity changed:235

g++环境输出结果：

capacity changed:

capacity changed: 2

capacity changed: 4

capacity changed: 8

capacity changed: 16

capacity changed: 32

capacity changed: 64

capacity changed: 128

capacity changed: 256

注意:

1. 严格来说capacity比实际空间少一个,有一个多的是预留给'\0'的。

2.如何扩容，C++标准并没有规定，取决于编译器的实现。比如在vs2019环境下，第一次是二倍扩容，后面都是1.5倍扩容；而g++环境下，一直是2倍扩容。

📌 max_size

size_t max_size() const;

使用max_size函数获取string对象对多可包含的字符数。

string s("CSDN");

cout << s.max_size() << endl; //4294967294

📌 clear

void clear();

clear的作用是把数据全部清理掉，它只是把string有效字符清空成为空串，只剩下\0，而不改变底层空间的大小。

//vs2019环境

string s1 = "hello";

cout << s1.size() << endl;//5

cout << s1.capacity() << endl;//15

s1.clear();

cout << s1.size() << endl; //输出 0

cout << s1.capacity() << endl;// 15

📌 empty

bool empty() const;

使用empty判断对象是否为空。

string s("CSDN");

cout << s.empty() << endl; //0

//clear()删除对象的内容，该对象将变为空字符串

s.clear();

cout << s.empty() << endl; //1

📌 reserve和resize

使用resize改变当前对象的有效字符的个数

void resize (size_t n);

void resize (size_t n, char c);

resize注意事项：

1. resize会改变对象的capacity和size。

2.当n大于对象当前的size时，将size扩大到n，扩大的字符为c，若c未给出，则默认为’\0’。

3. 当n小于对象当前的size时，将size缩小到n；缩不缩容取决于编译器，一般空间不变。

4. 若给出的n大于对象当前的capacity，则capacity也会根据自己的增长规则进行扩大。

string s1("hello");

s1.resize(6); //hello\0\0

s1.resize(20,'x');//helloxxxxxxxxxxxxxxx

//扩大

cout << s1.size() << endl; //20

cout << s1.capacity() << endl; //31

//缩小

s1.resize(10);

cout << s1.size() << endl; //10

cout << s1.capacity() << endl; //31

使用reserve改变当前对象的容量大小

void reserve (size_t n = 0);

string s("hello");

cout << s.capacity()<<endl; //15

//扩容

s.reserve(100);

cout << s.capacity()<<endl; //111

//缩容

s.reserve(20);

cout << s.capacity()<<endl; //111

s.reserve(10);

cout << s.capacity()<<endl;//10

我们可以得到在vs环境下扩容是会多扩的，而缩容传参数比capacity小是默认不会缩容的，小于15才会缩。

string s("hello");

cout << s.capacity()<<endl; //5

//扩容

s.reserve(100);

cout << s.capacity()<<endl; //100

//缩容

s.reserve(20);

cout << s.capacity()<<endl; //20

s.reserve(10);

cout << s.capacity()<<endl;//10

linux环境下,reserve扩容是要多少扩多少;缩容是要缩多少就缩到多少。

注 ：

1. reserve改变的是capacity，而不能改变size。

2.reserve改变空间(为string预留空间)，但不改变size(有效元素个数)要注意越界问题。

string s1("hello");

s1.resize(200);

s1[200]; //越界

3.由于扩容和缩容在不同平台的不确定性，所以我们最好用reserve来提前开好我们需要的空间，因此reserve的使用场景是知道需要提取开多少空间。

📌 shrink_to_fit

void shrink_to_fit();

string s1(100,'x');

cout << s1.capacity() << endl;//111

cout << s1.size()<< endl;//100

s1.resize(10);

s1.shrink_to_fit();

cout << s1.capacity() << endl;//15

cout << s1.size() << endl;//10

shirink_to_fit可以使size和capacity同步变化，但不要经常调用，因为实际的缩容是开新空间释放旧空间，以时间换空间代价较大。

🏠 算法与子串的提取

📌算法

📒 sort算法

库里的排序算法传参数是随机迭代器区间(左闭右开)，它可以对大部分容器(不能对list排序)进行排序，相当于是一个函数模板，利用迭代器这个桥梁将算法与容器连接起来。

<code>string s1("hello");

//按字典序排序 全部排

sort(s1.begin(),s1.end()); //ehllo

//第一个和最后一个不参与排序

sort(++s1.begin(),--s1.end()); //hello

//前4个排序

sort(s1.begin(),s1.begin()+4); //ehllo

注 ： 对于string容器使用sort排序是按字典序排序，同时它可以对整个数据处理，也可以对容器的一部分数据处理。

📒 reverse算法

算法库里的reverse也是一个函数模板，能对容器里的数据实现逆置，参数是迭代器区间。

<code>string s("hello");

reverse(s.begin(),s.end());

cout << s << endl; //olleh

注 ： 它也可以实现完全逆置和部分逆置，但是它和sort都需要包含<algorithm>这个头文件。

📌 子串的提取

使用substr函数提取string中的子字符串。

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

注 ： substr是pos位置开始生成len长度的子串，len过大或不传就是后面剩下的字符都变成子串，采取的也是左闭右开的迭代器区间。

string s1("abcdef");

string s2;

//substr(pos, n)提取pos位置开始的n个字符序列作为返回值

s2 = s1.substr(2, 4);

cout << s2 << endl; //cdef

使用copy函数将string的子字符串复制到字符数组中。

size_t copy (char* s, size_t len, size_t pos = 0) const;

string s("abcdef");

char str[20];

//copy(str, n, pos)复制pos位置开始的n个字符到str字符串

size_t length = s.copy(str, 4, 2);

//copy函数不会在复制内容的末尾附加'\0'，需要手动加

str[length] = '\0';

cout << str << endl; //dcef

注 ：

1. copy返回值是赋值的len。

2.copy函数不会在复制内容的末尾附加'\0'，需要我们手动加上。

🏠 查找

📌 find

使用find函数正向搜索第一个匹配项，可以在string对象里查找一个字符/字符串/string对象，返回的是第一个匹配的位置，未找到则返回-1.

size_t find (const string& str, size_t pos = 0) const;

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

size_t find (char c, size_t pos = 0) const;

string s1("http://www.cplusplus.com/reference/string/string/find/");

//find(string)正向搜索与string对象所匹配的第一个位置

string s2("www");

size_t pos1 = s1.find(s2);

cout << pos1 << endl; //7

//find(str)正向搜索与字符串str所匹配的第一个位置

char str[] = "cplusplus.com";

size_t pos2 = s1.find(str);

cout << pos2 << endl; //11

//find(char)正向搜索与字符char所匹配的第一个位置

size_t pos3 = s1.find(':');

cout << pos3 << endl; //4

📌rfind

使用rfind函数反向搜索第一个匹配项，rfind是倒着找一个字符/字符串/string对象，如果存在，返回匹配的第一个位置，否则返回-1.

size_t rfind (const string& str, size_t pos = npos) const;

size_t rfind (const char* s, size_t pos = npos) const;

size_t rfind (char c, size_t pos = npos) const;

string s1("http://www.cplusplus.com/reference/string/string/find/");

//rfind(string)反向搜索与string对象所匹配的第一个位置

string s2("string");

size_t pos1 = s1.rfind(s2);

cout << pos1 << endl; //42

//rfind(str)反向搜索与字符串str所匹配的第一个位置

char str[] = "reference";

size_t pos2 = s1.rfind(str);

cout << pos2 << endl; //25

//rfind(char)反向搜索与字符char所匹配的第一个位置

size_t pos3 = s1.rfind('/');

cout << pos3 << endl; //53

📌查找系列

<code>size_t find_first_of (const string& str, size_t pos = 0) const;

size_t find_first_of (const char* s, size_t pos = 0) const;

//其他类似...

std::string str ("Please, replace the vowels in this sentence by asterisks.");

std::size_t found = str.find_first_of("aeiou");

while (found!=std::string::npos)

{

str[found]='*';

found=str.find_first_of("aeiou",found+1);

}

std::cout << str << '\n';

🏠 输入与输出

📌 operator << 和 operator >> 

string类中也对>>和<<运算符进行了重载，这就是为什么我们可以直接使用>>和<<对string类进行输入和输出的原因。

ostream& operator<< (ostream& os, const string& str);

istream& operator>> (istream& is, string& str);

string s;

cin >> s; //输入

cout << s << endl; //输出

📌 getline

istream& getline (istream& is, string& str, char delim);

istream& getline (istream& is, string& str);

如果我们想输入一串含有空格的字符串到string对象中，使用cin是不行的，因为cin默认规定空格或换行是多个值之间分割，也就是当>>读取到空格便会停止读取。

string s;

getline(cin, s); //输入：hello CSDN

cout << s << endl; //输出：hello CSDN

getline函数将从is中提取到的字符存储到str中，直到读取到换行符’\n’为止。

string s;

getline(cin, s, 'D'); //输入：hello CSDN

cout << s << endl; //输出：hello CS

getline函数将从is中提取到的字符存储到str中，直到读取到分隔符delim或换行符’\n’为止。

🏠 string与其他数据类型转换

to_string : 其他数据类型转为字符串

库中提供了将其他数据类型转化为字符串的函数,但有时要注意数据溢出转换失败的风险。

<code>int x,y = 0;

cin >> x >> y; //输入 20 30

string str = to_string(x+y);

cout << str << endl; //输出50

sto.. : 字符串转化为其他数据类型。

注 ： 注意数据溢出的风险。

🏠 string与字符串的转化

将字符串转换为string

<code>//方式一

string s1("hello world");

//方式二

char str[] = "hello world";

string s2(str);

cout << s1 << endl; //hello world

cout << s2 << endl; //hello world

使用c_str或data将string转换为字符串

1. c_str作用是获取底层的ptr指针，它是为了更好的与c语言兼容。

2.data与c_str类似，就跟size与length的关系。

3.在C++98中，c_str()返回 const char* 类型，返回的字符串会以空字符结尾；在C++98中，data()返回 const char* 类型，返回的字符串不以空字符结尾

4. 在C++11版本中，c_str()与data()用法相同

string s("hello world ");

const char* str1 = s.data();

const char* str2 = s.c_str();

cout << str1 << endl;

cout << str2 << endl;

//

string file("Test.cpp");

cout << file.c_str() << endl;

🏠 vs和g++下string结构的不同

注意：下述结构是在32位平台下进行验证，32位平台下指针占4个字节。

vs下string的结构

string总共占28个字节，内部结构稍微复杂一点，先是有一个联合体，联合体用来定义string中字符串的存储空间：

1.当字符串长度小于16时，使用内部固定的字符数组来存放。

2.当字符串长度大于等于16时，从堆上开辟空间。

union _Bxty

{ // storage for small buffer or pointer to larger one

value_type _Buf[_BUF_SIZE];

pointer _Ptr;

char _Alias[_BUF_SIZE]; // to permit aliasing

} _Bx

这种设计也是有一定道理的，大多数情况下字符串的长度都小于16，那string对象创建好之后，内部已经有了16个字符数组的固定空间，不需要通过堆创建，效率高。

其次：还有一个size_t字段保存字符串长度，一个size_t字段保存从堆上开辟空间总的容量

最后：还有一个指针做一些其他事情。

故总共占16+4+4+4=28个字节。

g++下string的结构

G++下，string是通过写时拷贝实现的，string对象总共占4个字节，内部只包含了一个指针，该指针将来指向一块堆空间，内部包含了如下字段:

1. 空间总大小

2.字符串有效长度

3.引用计数

4.指向堆空间的指针，用来存储字符串

<code>struct _Rep_base

{

size_type _M_length;

size_type _M_capacity;

_Atomic_word _M_refcount;

};

关于引用计数和写时拷贝:

对于浅拷贝会遇到两个问题:

1. 由于两个string对象指向同一块空间,因此在析构两个对象时,会释放两次空间。

2. 由于两个对象指向同一块空间，因此一个对象修改数据会影响另一个对象。

解决方法：

1. 引用计数 ： 当每次为分配内存时，我们总是要多分配一个内存空间用来存放这个引用计数的值，只要发生拷贝构造和赋值时，这个内存值就会+1；当计数不为1时，不销毁空间；由最后一个析构的对象释放空间。

2. 写时拷贝：在内容修改时，string类查看这个引用计数是否为1，如果不为1，表示有人在共享这块内存，此时需要做一份深拷贝.也就是说，如果对这块内存不写就没有深拷贝只有浅拷贝，不修改就赚了，效率很高稳赚不赔。

🏠 relational operators 与 赋值

relational operators

string类中还对一系列关系运算符进行了重载，它们分别是==、!=、<、<=、>、>=。重载后的关系运算符支持string类和string类之间的关系比较、string类和字符串之间的关系比较、字符串和string类之间的关系比较。

<code>string s1("abcd");

string s2("abde");

cout << (s1 > s2) << endl; //0

cout << (s1 < s2) << endl; //1

cout << (s1 == s2) << endl; //0

注意：这些重载的关系比较运算符所比较的都是对应字符的ASCII码值。

赋值

string类中对=运算符进行了重载，重载后的=运算符支持string类的赋值、字符串的赋值以及字符的赋值。

string s1;

string s2("CSDN");

//支持string类的赋值

s1 = s2;

cout << s1 << endl; //CSDN

//支持字符串的赋值

s1 = "hello";

cout << s1 << endl; //hello

//支持字符的赋值

s1 = 'x';

cout << s1 << endl; //x

---

完。