1. 为什么学习string类？

1.1 C语言中的字符串

1.2 编程题解答

void Teststring()
{string s1; // 构造空的string类对象s1string s2("hello"); // 用C格式字符串构造string类对象s2string s3(s2); // 拷贝构造s3
}

2.2.2代码实现：

我们基本不用第三种，所以这里只实现 124，我们把12通过缺省参数来结合

class string
{
public:string(const char* str = "")//"\0"=="",因为结尾没有'\0'会补: _size(strlen(str)), _capacity(_size == 0 ? 3 : _size){_str = new char[_capacity + 1];//_capacity不包括最后的'\0'strcpy(_str, str);}string(const string& s):_size(s._size), _capacity(_size==0?3:_size){_str = new char[_size + 1];strcpy(_str, s._str);}private:char* _str;size_t _size;//大小不包括'\0',表示这个字符指针所容纳的字符数量size_t _capacity;//大小不包括'\0'，表示字符指针指向的空间的大小，即开辟的空间大小
};

• 1. size()与length()方法底层实现原理完全相同，因为string的出现是早于STL的，一开始也只有length，但后来在STL中别的容器（例如队列，链表，树）用的都是size，为了保证接口一致，于是又给string设计了size接口，一般情况下基本都是用size()。
• 2. clear()只是将string中有效字符清空，不改变底层空间大小。

• 3. reserve：为string预留空间，不改变有效元素个数，当reserve的参数小于 string的底层空间总大小时，reserver不会改变容量大小。
• 4. resize(size_t n) 与 resize(size_t n, char c) 都是将字符串中有效字符个数改变到 n 个，不同的是当字符个数增多时：resize(n) 用 0 来填充多出的元素空间， resize(size_t n, char c) 用字符 c 来填充多出的元素空间。注意：resize 在改变元素个数时，如果是将元素个数增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。我们也是利用缺省参数将二者合并。

2.3.2代码实现

class string{public:size_t size()const//length的实现与它完全一样，就是名字不一样{return _size;}size_t capacity()const{return _capacity;}bool empty(){return _size == 0;}void clear(){strcpy(_str, "");_size = 0;}void reserve(size_t a){if (a > _capacity)//扩容，那就要重新开辟一份空间{char* str = new char[a + 1];strcpy(str, _str);//将原本的数拷贝到开的空间delete[] _str;//释放原来的空间，防止内存泄漏_str = str;_capacity = a;//更改所记录的容量值}}void resize(size_t a,char ch='\0'){if (a > _capacity){char* str = new char[a + 1];//记得多开一个给'\0'strcpy(str, _str);delete[] _str;_str = str;while (_size != a)//将多余的空间进行赋初值{_str[_size] = ch;}_str[_size] = '\0';_capacity = a;}else{_size = a;_str[_size] = '\0';//不缩容，只要改记录的_size就好了}}private:char* _str;size_t _size;//大小不包括'\0',表示这个字符指针所容纳的字符数量size_t _capacity;//大小不包括'\0'，表示字符指针指向的空间的大小，即开辟的空间大小};

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

2.4.1介绍

class string
{
public:string& operator+=(const char* str){this->append(str);//与append作用相同，所以直接调用函数return *this;}string& operator+=(const char ch)//与push_back作用相同，所以直接调用函数{this->push_back(ch);return *this;}string& operator+=(const string& s){this->append(s._str);//与append作用相同，所以直接调用函数return *this;}void push_back(const char ch){if (_size + 1 > _capacity)//就扩容{reserve(_capacity * 1.5);//1.5倍扩容}_str[_size] = ch;_size++;_str[_size] = '\0';//结尾是'\0'别忘了}void append(const char* str){size_t len = strlen(str);if (_size + len > _capacity)//就扩容{reserve(_capacity + len);}strcpy(_str + _size, str);_size += len;//——capacity已经在reserve中调整过了}size_t find(const char ch, size_t pos = 0)//从下标为pos出开始查找，看有没有目标字符{assert(pos < _size);for (size_t i = pos; i < _size; i++){if (_str[i] == ch)return i;}return npos;}size_t find(const char* str, size_t pos = 0){assert(pos < _size);char* p = strstr(_str + pos, str);从下标为pos出开始查找，看有没有目标字符串if (p == nullptr)return npos;//npos的值就是无符号数的-1，也就是42亿多return p - _str;}const char* c_str(){return _str;}
private:char* _str;size_t _size;//大小不包括'\0',表示这个字符指针所容纳的字符数量size_t _capacity;//大小不包括'\0'，表示字符指针指向的空间的大小，即开辟的空间大小static size_t npos;
};
size_t string::npos = -1;

	ostream& operator<<(ostream& out, string& d){for (auto& c : d)//不能out<<_str,因为可能中间有'\0'out << c;for (string::iterator it = d.begin(); it < d.end(); it++)cout << *it;return out;}istream& operator>>(istream& in, string& s){s.clear();char ch;char buff[128] = { 0 };int i = 0;ch = in.get();//直接in插入，接收不到空格while (ch != ' ' && ch != '\n'){if (i >= 0 && i < 127){buff[i++] = ch;}else if (i == 127){buff[127] = '\0';s += buff;s += ch;i = -1;}elses += ch;ch = in.get();}if (i >= 0)s += buff;return in;}

2.8string的插入和删除

	string& insert(size_t pos, const char* str)//在pos插入一个str指向的字符数组，原下标pos{                                         //以及之后的元素向后移位assert(pos <= _size);//插入位置是否越界int len = strlen(str);int i = _size + len;_str[i] = '\0';i--;if (_size + len > _capacity)reserve(_capacity + len);while (i >= pos + len)//类型转换{_str[i] = _str[i - len];i--;}i = strlen(str);while (i > 0){_str[pos + i - 1] = str[i - 1];i--;}_size += len;return *this;}string& insert(size_t pos,int size ,const char ch)//在pos插入目标字符，原下 //标pos以及之后的元素向后移位{assert(pos <= _size);//插入位置是否越界int i = _size + 1;if (_size + 1 > _capacity)reserve(_capacity *1.5);while (i >= pos + 1)//类型转换{_str[i] = _str[i - 1];i--;}_str[pos] =ch;i--;_size += 1;return *this;}string& erase(size_t pos, size_t len = npos)//npos是-1的无符号数强转，即42亿多，一个字符数组不会这末长，{                                         //结果就是把pos及后面的内容都删了。if (pos + len > _size || len == npos)//从下标pos出开始删除，一直删除狗len个元素或删完。{_size = pos;_str[_size] = '\0';}else{strcpy(_str + pos, _str + pos + len);_size -= len;}return *this;}

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;

class String
{
public:String(const char* str = ""){if (nullptr == str){assert(false);return;}_str = new char[strlen(str) + 1];strcpy(_str, str);}String(const String& s): _str(nullptr){String strTmp(s._str);swap(_str, strTmp._str);}// 对比下和上面的赋值那个实现比较好？String& operator=(String s){swap(_str, s._str);return *this;}/*String& operator=(const String& s){if(this != &s){String strTmp(s);swap(_str, strTmp._str);}
return *this;}*/~String(){if (_str){delete[] _str;_str = nullptr;}}
private:char* _str;
};