Welcome to 9ilk's Code World
(๑•́ ₃ •̀๑) 个人主页: 9ilk
(๑•́ ₃ •̀๑) 文章专栏: 与C++的邂逅
本篇博客我们将来了解string容器本身以及接口的使用。
string是串,本质是一个字符数组,可以对其进行增删查改。
? string构造
//常用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是整形最大值,一定大于后面的长度,不传第三个参数默认拷贝到结尾.
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的位置.
迭代器的版本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 |
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
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; //+=strings1 += "C++" ; //+=字符串s1 += '!'; //+=字符
? 尾部删除
void pop_back();string str ("hello world!");str.pop_back();cout << str << '\n'; //hello world
我们可以用pop_back来删除string对象的尾部字符。
? insert和erase
insertstring& 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位置插入字符串strs.insert(1, "H"); //CH//insert(pos, string)在pos位置插入string对象string t("I");s.insert(2, t); //CHI//insert(pos, char)在pos位置插入字符chars.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其实可以复用来实现尾插头插。
erasestring& 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; //输出ellos.erase(0, 20);cout << s << endl;//输出空串
注 : erase也是一样要慎用效率不高,也是O(N)
? assign
string& assign (const string& str);string& assign (const char* s);//应用//const char* strstring s1("hello world");s1.assign("yes");cout << s1 << endl; //输出yes//stringstring 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");// helloworldacout << 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;}elsei++;}
我们可以用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; //输出5cout << 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;//5cout << s1.capacity() << endl;//15s1.clear();cout << s1.size() << endl; //输出 0cout << 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\0s1.resize(20,'x');//helloxxxxxxxxxxxxxxx//扩大cout << s1.size() << endl; //20cout << s1.capacity() << endl; //31 //缩小s1.resize(10);cout << s1.size() << endl; //10cout << 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; //111s.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; //20s.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;//111cout << s1.size()<< endl;//100s1.resize(10);s1.shrink_to_fit();cout << s1.capacity() << endl;//15cout << s1.size() << endl;//10
shirink_to_fit可以使size和capacity同步变化,但不要经常调用,因为实际的缩容是开新空间释放旧空间,以时间换空间代价较大。
? 算法与子串的提取
?算法
? sort算法
库里的排序算法传参数是随机迭代器区间(左闭右开),它可以对大部分容器(不能对list排序)进行排序,相当于是一个函数模板,利用迭代器这个桥梁将算法与容器连接起来。
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也是一个函数模板,能对容器里的数据实现逆置,参数是迭代器区间。
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
?查找系列
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 CSDNcout << s << endl; //输出:hello CSDN
getline函数将从is中提取到的字符存储到str中,直到读取到换行符’\n’为止。
string s;getline(cin, s, 'D'); //输入:hello CSDNcout << s << endl; //输出:hello CS
getline函数将从is中提取到的字符存储到str中,直到读取到分隔符delim或换行符’\n’为止。
? string与其他数据类型转换
to_string : 其他数据类型转为字符串库中提供了将其他数据类型转化为字符串的函数,但有时要注意数据溢出转换失败的风险。
int x,y = 0;cin >> x >> y; //输入 20 30string str = to_string(x+y);cout << str << endl; //输出50
sto.. : 字符串转化为其他数据类型。 注 : 注意数据溢出的风险。
? string与字符串的转化
将字符串转换为string//方式一string s1("hello world");//方式二char str[] = "hello world";string s2(str);cout << s1 << endl; //hello worldcout << 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 onevalue_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.指向堆空间的指针,用来存储字符串
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 operatorsstring类中还对一系列关系运算符进行了重载,它们分别是==、!=、<、<=、>、>=。重载后的关系运算符支持string类和string类之间的关系比较、string类和字符串之间的关系比较、字符串和string类之间的关系比较。
string s1("abcd");string s2("abde");cout << (s1 > s2) << endl; //0cout << (s1 < s2) << endl; //1cout << (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
完。