天猫店怎么申请广西网络优化seo

1.为什么学习string类

1.1 C语言中的字符串

C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数， 但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。

1.2 笔试面试题

在OJ中，有关字符串的题目基本以string类的形式出现，而且在常规工作中，为了简单、方便、快捷，基本 都使用string类，很少有人去使用C库中的字符串操作函数。

2.标准中的string类

2.1 string类

1. 字符串是表示字符序列的类
2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。
3. string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信 息，请参阅basic_string)。
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits 和allocator作为basic_string的默认参数(根于更多的模板信息请参考basic_string)。
5. 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作。

总结：

1. string是表示字符串的字符串类
2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。
3. string在底层实际是：basic_string模板类的别名，typedef basic_string string;
4. 不能操作多字节或者变长字符的序列。

注意：在使用string类时，必须包含#include头文件以及using namespace std;

#include<string>
using namespace std;

2.2 string类的常用接口说明

1. string类对象的常用构造

构造函数

//string管理动态增长的字符数组，这个字符传以\0结尾以兼容C语言
int main()
{string s1;//1.无参构造空字符串string s2("hello world");//2.带参构造函数：用C—string来构造string类对象，当然，此处还有下面的一种形式char str[] = "hello world";string s2(str);//这个地方发生了类型转换，str的类型是char*，然后被转换成了const char*string s3(s2);//3.拷贝构造函数：形式1string s3 = s2;//3.拷贝构造函数：形式2string s4(10, 'c');//4.string类对象中包含10个'c'return 0;
}

除了上述几个常用的之外，还有几个不是特别常用的，仅作了解：

//形式：string(const char* s, size_t n);(用字符串s的前n个字符构成的字符串来对字符串进行构造)
string s1("hello world", 5);//相当于string s1("hello");//"hello"是"hello world"的前5个字符形成的字符串
//形式：string (const string& str, size_t pos, size_t len = npos);(用从str的pos位置开始的len个字符形成的字符出啊来对字符串进行构造,npos有一个缺省值（static const size_t类型），是-1，所以当npos缺省的时候就是将从pos位置开始的字符一直到最后一个字符全部都用来对字符串进行构造)
string s1("hello world");
string s2(s1, 4, 5);//用从o开始的5个字符形成的字符串来对s2字符串进行构造，即o wor
//注意：当pos + npos超出字符串长度的时候，就会把从pos开始的所有字符串都拿来对s2进行初始化

析构函数

因为string类型是动态管理的，如果不需要使用了就需要去主动给释放，所以有了string类的析构函数。

注意：string类型的析构函数是自动调用的，不需要去手动调用，出了作用域自动销毁。

赋值运算符重载

使用举例：

string s1("hello");
string s2("world");
s1 = s2;//第一种形式：最常用
s1 = "world";//第二种形式
s1 = 'H';//第三种形式

2. string类对象的容量操作

使用举例：

// size/clear/resize
void Teststring1()
{// 注意：string类对象支持直接用cin和cout进行输入和输出string s("hello world!!!");cout << s.size() << endl;//输出结果为11cout << s.length() << endl;//输出结果为11cout << s.capacity() << endl;//输出结果为一个大于11的数字// 将s中的字符串清空，注意清空时只是将size清0，不改变底层空间的大小s.clear();cout << s.size() << endl;//输出结果为0cout << s.capacity() << endl;//输出结果为0cout << s << endl;//输出结果为空// 将s中有效字符个数增加到10个，多出位置用'a'进行填充// “aaaaaaaaaa”s.resize(10, 'a');cout << s.size() << endl;//输出结果为10cout << s.capacity() << endl;//输出结果为一个大于10的数据// 将s中有效字符个数增加到15个，多出位置用缺省值'\0'进行填充// "aaaaaaaaaa\0\0\0\0\0"// 注意此时s中有效字符个数已经增加到15个s.resize(15);cout << s.size() << endl;//输出结果为15cout << s.capacity() << endl;//输出结果不变cout << s << endl;//输出结果为aaaaaaaaaa// 将s中有效字符个数缩小到5个，capacity并没有改变，size被改变了s.resize(5);cout << s.size() << endl;//输出结果为5cout << s.capacity() << endl;//输出结果没有改变cout << s << endl;//输出结果为aaaaa
}
//================================================================================
====
void Teststring2()
{string s;// 测试reserve是否会改变string中有效元素个数s.reserve(100);cout << s.size() << endl;//输出结果为0cout << s.capacity() << endl;//输出结果为一个大于100的数据// 测试reserve参数小于string的底层空间大小时，是否会将空间缩小s.reserve(50);cout << s.size() << endl;//输出结果为0cout << s.capacity() << endl;//输出结果不变
}
// 利用reserve提高插入数据的效率，避免增容带来的开销（在VS下扩容大概是1.5倍左右）
//================================================================================
====
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';}}
}
void TestPushBackReserve()
{string s;s.reserve(100);//一开始就设定一个容量（size并没有被改变），就不存在扩容了，避免了扩容消耗，因为存在对齐现象，并不会严格的一致，可能稍微大于我们设定的容量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';}}
}

其它关于容量的操作：

注意：

1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一 致，一般情况下基本都是用size()。
2. clear()只是将string中有效字符清空，不改变底层空间大小。
3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。
   注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。
4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserver不会改变容量大小。

3. string类对象的访问及遍历操作

使用举例：

int main()
{string str("hello");//遍历string中的每一个字符//第一种方式：下标 + []法for (size_t i = 0; i < str.size(); i++){cout << str[i] << " ";//相当于是调用下面的函数//cout << str.operator[](i) << " ";}//第二种方式：迭代器（像指针一样的东西或者就是指针，看底层的具体实现）//注意：//end不指向最后一个数据，指向最后一个有效数据的下一个位置，在string中是'\0'，即[)，左闭右开区间string::iterator it = str.begin();//iterator是string类中定义的，是string的内嵌类型while (it != str.end())//如果要遍历的是数据是连续存储的物理空间，可以用<，如果不是连续存储的，就必须用!={cout << *it << " ";it++;}//第三种方式：范围for（实际会被替换成迭代器）for (auto& i : str){cout << i << " ";}
}

反向迭代器与const迭代器

反向迭代器：

作用：反向迭代器可以对字符串进行倒序遍历访问。

作用：rbegin指向最后一个有效字符。

作用：rend指向第一个字符的前一个位置。

使用举例：

string s1("hello world");
string::reverse_iterator rIt = s1.rbegin();
while (rIt != s1.rend())
{cout << *rIt << " ";rIt++;
}

运行结果：

常迭代器：

作用：常迭代器用来对const类型的字符串进行遍历访问。因为普通的迭代器具有可读可写的权限，但是常迭代器只具有可读的权限。

下面是一种方式：

方法一：（C++11，不常用）

string::const_iterator cIt = s1.cbegin;
string::const_iterator cIt = s1.cend();
string::const_reverse_iterator It = s1.crbegin();
string::const_reverse_iterator It = s1.crend();

方法二：（一般用这个）

使用举例：

string::const_iterator cIt = s1.begin;
string::const_iterator cIt = s1.end();
string::const_reverse_iterator It = s1.rbegin();
string::const_reverse_iterator It = s1.rend();

遍历字符串的例题：

代码：

//方法一：下标的方法
class Solution {
public:bool isLetter(char ch){if (ch >= 'a' && ch <= 'z')return true;else if (ch >= 'A' && ch <= 'Z')return true;elsereturn false;}string reverseOnlyLetters(string s) {size_t left = 0;size_t right = s.size() - 1;while(left < right){while(left < right && !isLetter(s[left])){left++;}while(left < right && !isLetter(s[right])){right--;}swap(s[left],s[right]);left++;right--;}return s;}
};
//方法二：迭代器的方法
class Solution {
public:bool isLetter(char ch){if (ch >= 'a' && ch <= 'z')return true;else if (ch >= 'A' && ch <= 'Z')return true;elsereturn false;}string reverseOnlyLetters(string s) {string::iterator left = s.begin();string::iterator right = s.end() - 1;while (left < right){//cout<<left<<":"<<right<<endl;while (left < right && !isLetter(*left))++left;while (left < right && !isLetter(*right))--right;swap(*left, *right);++left;--right;}return s;}
};

问：此处为什么只需要一个swap就能对两个字符串对应位置的字符进行交换呢？

答：因为C++编译器默认提供了swap函数，如下图所示：

通过函数模板的实现，可以通过swap函数来交换任意类型的两个数据。

一些其它的遍历访问方式

• at

  

  也是访问字符串pos位置处的字符，和[]的作用基本一致，使用举例：

  string s1("hello");
  s1.at(0) = 'y';//将字符串第一个位置处的字符即h修改为y
  

  注意：at和[]的区别在于越界访问。

  []:

  

  []在越界的时候会引起未定义的行为（在VS2019的情况下是断言）。

  at:

  

  at在越界的时候会引发异常。

• back和front

  

  

  作用：back是返回最后字符串的最后一个字符，front是返回第一个字符。

  使用举例：

  string s1("hello");
  cout << s1.front() << s1.back() << endl;//打印结果为ho
  

4. string类对象的修改操作

详细了解push_back

代码练习：

int main()
{string s1 = "hello world";s1.push_back('c');//在字符串s1的后面添加字符'c'//添加后字符串s1变成了"hello worldc"return 0;
}

详细了解append

代码练习：

int main()
{string s1 = "hello ";string s2 = "world";s1.append(s2);//在字符串s1的后面添加字符串s2，添加后字符串s1变成了"hello world"s1 = "hello ";s2 = "world";s1.append(s2, 3, 2);//在字符串s1的后面添加字符串s2从第三个字符开始的2个字符组成的字符串即"ld"，此时s1变成了"hello ld"s1 = "hello ";s1.append("world");//在字符串s1的后面添加字符串"world"return 0;
}

详细了解c_str

代码练习：

int main()
{string s1 = "hello world";const char* str = s1.c_str();//返回指向string类型的s1中存储"hello world"首字符的地址cout << s1 << endl;//调用的是字符串类型的运算符重载cout << str << endl;//调用的也是运算符重载，不过针对的是char* 类型的运算符重载//上述两种方式都能够正确打印出"hello world"return 0;
}

详细了解find和rfind

详细了解substr

代码练习：

//要求取出文件的后缀
int main()
{string file = "file.cpp";size_t pos = file.find('.');if (pos != string::npos){string suffix = file.substr(pos, str.size() - pos);cout << suffix << endl;//substr的第二个参数默认是无符号整数的最大值//substr是返回从pos开始的len个字符组成的string类型的字符串}else{cout << "不存在后缀" << endl;}return 0;
}

此时需要考虑一种情况，当文件名为file.c.tar.zip时我们该如何拿到该文件名的后缀.zip呢？

代码练习：

int main()
{string file = "file.cpp";size_t pos = file.rfind('.');//倒着找即可if (pos != string::npos){string suffix = file.substr(pos, str.size() - pos);cout << suffix << endl;//substr的第二个参数默认是无符号整数的最大值//substr是返回从pos开始的len个字符组成的string类型的字符串}else{cout << "不存在后缀" << endl;}return 0;
}

了解find的扩展

用法和前面的find相类似，不过find_first_of是找到第一个c字符的位置的字符的下标，find_last_of是返回最后一个c字符的位置的字符的下标，find_first_not_of是找到第一个非c字符的位置的字符的下标，find_last_not_of是返回最后一个非c字符的位置的字符的下标。

find的应用场景：找到url中的协议、域名、uri

int main()
{string url1("https://www.cnblogs.com/tfknight/p/12793248.html");//协议 域名 uristring& url = url1;string protocol;//协议size_t pos1 = url.find("://");if (pos1 != string::npos){protocol = url.substr(0, pos1);cout << "protocol:" << protocol << endl;}else{cout << "非法url" << endl;}string domain;//域名size_t pos2 = url.find('/', pos1 + 3);//从w位置开始找if (pos2 != string::npos){domain = url.substr(pos1 + 3, pos2 - (pos1 + 3));cout << "domain:" << domain << endl;}else{cout << "非法url" << endl;}string uri = url.substr(pos2 + 1);cout << "uri:" << uri << endl;return 0;
}

详细了解insert

代码练习：

int main()
{string s1("world");s1.insert(0, "hello ");//在字符串s1的首字符处插入一个字符串"hello "，此时s1变成"hello world"cout << s1 << endl;s1.insert(0, 1, 'x');//在字符串s1的第一个字符处插入一个字符'x'，此时字符串变成了"xhello world"cout << s1 << endl;s1.insert(s1.begin(), 1, 'y');//在字符串s1的第一个位置处，插入一个字符'y'，此时字符串s1变成了"yxhello world"cout << s1 << endl;s1.insert(3, 1, 'x');//在字符串s1的第三个位置处插入一个字符'x'，此时字符串s1变成了"yxhxello world"cout << s1 << endl;s1.insert(s1.begin() + 3, 1, 'y');//在字符串s1的第三个位置处插入一个字符'y'，此时字符串s1变成了"yxhyxello world"cout << s1 << endl;return 0;
}

打印结果：

详细了解erase

符号解释：

代码练习：

int main()
{string s1("hello world");s1.erase();//默认pos是0，len是npos，即无符号整数的最大值cout << s1 << endl;string s2 = "hello world";s2.erase(3);//删除从第三个字符往后的所有字符cout << s2 << endl;string s3 = "hello world";s3.erase(3, 2);//删除从第三个字符向后的两个字符cout << s3 << endl;return 0;
}

运行截图：

详细了解assign

代码练习：

int main()
{string s1 = "hello world";string s2 = "hahaha";s1.assign(s2);//将s2赋值给s1cout << s1;return 0;
}

详解swap

库里的swap:

本质上是通过拷贝构造和赋值实现了，使用了深拷贝。

代码练习：

int main()
{string s1 = "hello world";string s2 = "hahaha";s1.swap(s2);//效率比较高，本质就是交换指针swap(s1, s2);//效率比较低，本质是一种深拷贝cout << s1 << endl << s2 << endl;return 0;
}

5. string类对象的非成员函数

详细了解getline

注意：getline只有当遇到换行符的时候才会停止输入，而cin遇到空格、换行、tab键时都会停止输入。

详细了解stoi

详细了解to_string

6. 牛刀小试

1.找字符串中第一次只出现一次的字符

class Solution {
public:int firstUniqChar(string s) {int count[26] = {0};for(auto e : s){count[e - 'a']++;}for(size_t i = 0; i < s.size(); i++){if(count[s[i] - 'a'] == 1){return i;}}return -1;}
};

2.字符串最后一个单词的长度

#include<iostream>
using namespace std;
int main()
{string str;getline(cin, str);size_t pos = str.rfind(' ');if(pos != string::npos){cout << str.size() - pos - 1;}else{cout << str.size();}return 0;
}

3.字符串相加

class Solution {
public:string addStrings(string num1, string num2) {int end1 = num1.size() - 1;int end2 = num2.size() - 1;int carry = 0;string ret;while(end1 >= 0 || end2 >= 0 || carry == 1)//carry == 1是为了防止最后只剩一个进位的时候，即"1" + "9" = "10"的这种情况{int value1 = 0;int value2 = 0;value1 = end1 >= 0 ? num1[end1] - '0' : 0;value2 = end2 >= 0 ? num2[end2] - '0' : 0;int tmp = value1 + value2 + carry;//tmp用来临时存储相加的值if(carry == 1)//如果上一次的进位为1就将其置为0{carry = 0;}if(tmp > 9){tmp %= 10;carry += 1;}ret.push_back(tmp + '0');end1--;end2--;}reverse(ret.begin(), ret.end());//将字符串进行逆置return ret;}
};

2.3 关于string的大小问题

环境：Windows下的VS2019环境下：

#include<iostream>
#include<string>
using namespace std;
int main()
{string s1("1111111111");string s2("2222222222222222222222222222222222222222222");cout << "sizeof(s1):" << sizeof(s1) << endl;cout << "sizeof(s2):" << sizeof(s2) << endl;return 0;
}

输出结果：

class string
{
private:char _buf[16];//小于16字节的字符串，直接存到buf中char* _ptr;//大于等于16字节的字符串，存在_ptr指向的空间中//注意：二者存放是只能选择其一的，即我们想要存储的字符串，要么存放到_buf中，要么存放到_ptr指向的空间中size_t _size;size_t _capacity;
}

3. string类的模拟实现

3.1 浅拷贝与深拷贝

浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。

深拷贝：如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情 况都是按照深拷贝方式提供。

3.2 string的模拟实现

class mystring
{
public:typedef char* iterator;typedef const char* const_iterator;//普通迭代器的实现iterator begin(){return _str;}iterator end()//返回最后一个有效字符的下一个位置{return &_str[_size];//return _str + _size;}//const迭代器的实现const_iterator begin() const{return _str;}const_iterator end()const{return &_str[_size];}//构造函数mystring(const char* str = ""):_size(strlen(str)),_capacity(_size){_str = new char[_capacity + 1];strcpy(_str, str);}//拷贝构造函数mystring(const mystring& s):_size(strlen(s._str)),_capacity(_size){_str = new char[_capacity + 1];strcpy(_str, s._str);}//析构函数~mystring(){if (_str){delete[]_str;_str = nullptr;_size = _capacity = 0;}}//c_str函数const char* c_str()const{return _str;}//[]运算符重载char& operator[](size_t pos){assert(pos < strlen(_str));return _str[pos];}//const对象的[]运算符重载const char& operator[](size_t pos) const{assert(pos < strlen(_str));return _str[pos];}//赋值运算符重载mystring& operator=(const mystring& s){if (&s != this)//防止s1 = s1这种情况{char* tmp = new char[strlen(s._str) + 1];strcpy(tmp, s._str);delete[] _str;//不先释放_str是为了防止空间开失败的情况_str = tmp;_size = s._size;_capacity = s._capacity;}return *this;}//push_back()函数模拟void push_back(char ch){if (_capacity == _size){reserve(_capacity == 0 ? 4 : 2 * _capacity);}_str[_size++] = ch;_str[_size] = '\0';}//+=运算符重载mystring& operator+=(char ch){push_back(ch);return *this;}//+=运算符重载mystring& operator+=(const char* str){append(str);return *this;}//+=运算符重载mystring& operator+=(const mystring& s){append(s.c_str());return *this;}//reserve()函数模拟实现void reserve(size_t n){if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}}//resize()函数模拟实现void resize(size_t n, char ch = '\0'){if (n > _capacity){reserve(n);for (size_t i = _size; i < n; i++){push_back(ch);}_size = n;_str[_size] = '\0';}else{_str[n] = '\0';_size = n;}}//append()函数模拟实现void append(const char* str)//也可复用insert{size_t len = strlen(_str) + strlen(str);if (len > _capacity){reserve(len);}strcpy(_str + _size, str);_size = len;}//insert()函数（插入字符）模拟实现mystring& insert(size_t pos, char ch)//push_back就是尾插所以可以复用insert{assert(pos <= _size);if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}size_t end = _size + 1;//因为end是无符号数，所以不能让end为-1while (end > pos){_str[end] = _str[end - 1];--end;}_str[pos] = ch;_size++;return *this;}//insert()函数（插入字符串）模拟实现mystring& insert(size_t pos, const char* str){assert(pos <= _size);size_t len = strlen(str);if (_size == _capacity){reserve(_capacity == 0 ? 4 : _capacity * 2);}size_t end = _size + len;while (end > pos + len - 1)//注意：while(end >= pos + len)，当pos和len都是0的时候就会出现死循环{_str[end] = _str[end - len];--end;}strncpy(_str + pos, str, len);_size += len;return *this;}//size函数size_t size() const{return strlen(_str);}//capacity()函数模拟实现size_t capacity() const {return _capacity;}//erase()函数模拟实现mystring& erase(size_t pos, size_t len = npos){assert(pos < _size);if (len == npos || pos + len >= _size){_str[pos] = '\0';_size = pos;}else{size_t begin = pos + len;while (begin <= _size){_str[begin - len] = _str[begin];++begin;}_size -= len;}return *this;}//find()函数模拟实现（查找一个字符）size_t find(char ch, size_t pos = 0){for (; pos < _size; ++pos){if (_str[pos] == ch){return pos;}}return npos;}//find()函数模拟实现（查找一个字符串）size_t find(char* ch, size_t pos = 0){const char* p = strstr(_str + pos, ch);if (p == nullptr){return npos;}else{return p - _str;}}//clear()函数模拟实现void clear(){_str[0] = '\0';_size = 0;}
private:char* _str;size_t _size;size_t _capacity;const static size_t npos;
};
const size_t mystring::npos = -1;
//各种运算符重载
bool operator<(const mystring s1, const mystring s2)
{return strcmp(s1.c_str(), s2.c_str()) < 0;
}
bool operator==(const mystring s1, const mystring s2)
{return strcmp(s1.c_str(), s2.c_str()) == 0;
}
bool operator<=(const mystring s1, const mystring s2)
{return s1 < s2 || s1 == s2;
}
bool operator>(const mystring s1, const mystring s2)
{return !(s1 <= s2);
}
bool operator>=(const mystring s1, const mystring s2)
{return !(s1 < s2);
}
bool operator!=(const mystring s1, const mystring s2)
{return !(s1 == s2);
}
//流插入运算符重载
std::ostream& operator<<(std::ostream& out, const mystring& s)
{for (auto e : s){out << e;}return out;
}
//流提取运算符重载（第一种实现方式）
std::istream& operator>>(std::istream& in, mystring& s)
{s.clear();char ch;ch = in.get();while (ch == ' ' || ch == '\n'){s += ch;ch = in.get();}return in;
}
//流提取运算符重载（第二种实现方式）（推荐）
std::istream& operator>>(std::istream& in, mystring& s)
{s.clear();char ch;ch = in.get();char buff[128] = { '\0' };size_t i = 0;while (ch != ' ' && ch != '\n'){buff[i++] = ch;if (i == 127){s += buff;memset(buff, '\0', 128);i = 0;}ch = in.get();}s += buff;return in;
}

上面的是传统的string模拟实现，下面的是现代string的模拟实现：

void swap(mystring& s)
{std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);
}
//现代拷贝构造函数写法
mystring(const mystring& s):_str(nullptr), _size(0), _capacity(0)
{mystring tmp(s._str);swap(tmp);
}

图示：

//比较繁琐的写法
mystring& operator=(const mystring& s)
{if (this != &s){mystring tmp(s._str);swap(tmp);}return *this;
}
//更简洁的赋值运算符重载(推荐)
mystring& operator=(mystring s)//s是s1的一份临时拷贝，调用了拷贝构造函数
{swap(s);return *this;
}
//问：这里为什么不需要判断自己给自己赋值？
//答：当自己给自己进行赋值的时候，就是将原来的数据进行一次深拷贝，即挪动了一x