对于命名空间std的string类，现在我们手动实现，了解string类运作的大致逻辑。

大体框架

现在对于string需要的成员函数以及成员变量，需要先列出来，方便后边的书写

namespace x
{class string{public:string(const char* str = ""){}string(const string& s);//拷贝构造string& operator=(const string& s);//赋值拷贝~string(){}//析构size_t capacity()const;//返回容量size_t size()const;//返回此时大小char& operator[](size_t pos);//返回指定位置的字符const char& operator[](size_t pos)const{}void push_back(char ch);//尾插字符void reserve(size_t n);//扩容void append(const char* str);//增加字符串string& operator+=(char ch);//增加字符string& operator+=(const char* str);//增加字符串void insert(size_t pos, char ch);//插入bool operator<(const string& s)const//比较{}bool operator==(const string& s)const{}bool operator<=(const string& s)const{}bool operator>=(const string& s)const{}bool operator>(const string& s)const{}bool operator!=(const string& s)const{}void clear();void erase(size_t pos, size_t len = npos);//消除指定位置的数据string substr(size_t pos,size_t len=npos);size_t find(const char* sub, size_t pos = 0);size_t find(char ch, size_t pos=0);void resize(size_t n, char ch = '\0');private:char* _str;size_t _size;size_t _capacity;static const size_t npos = -1;};
}

初始化列表

string(const char* str = ""):_size(strlen(str)), _capacity(_size + 1)
{_str = new char[_capacity + 1];strcpy(_str, str);//内容拷贝过去
}
~string()
{delete[]_str;_capacity = _size = 0;_str = nullptr;
}//析构

返回容量、大小

size_t capacity()const
{return _capacity;
}//返回容量
size_t size()const
{return _size;
}//返回此时大小

返回指定位置的字符

char& operator[](size_t pos)
{assert(pos < _size);return _str[pos];
}//返回指定位置的字符
const char& operator[](size_t pos)const
{assert(pos < _size);return _str[pos];
}

扩容，开辟空间

void reserve(size_t n)
{if (n > _capacity){char* tmp = new char[n + 1];//留一个空位给' \0 'strcpy(tmp, _str);delete[]_str;//释放_str,将新定义好的tmp赋值给_str_str = tmp;_capacity = n;}
}//扩容

尾插字符/字符串

void push_back(char ch){if (_size == _capacity){reserve(_capacity = 0 ? 4 : 2 * _capacity);}_str[_size] = ch;++_size;_str[_size] = '\0';}//尾插字符void append(const char* str)
{size_t n = strlen(str);if (_size + n > _capacity){reserve(_size + n);}strcpy(_str + _size, _str);//将原来的放入扩容的位置处_size += n;
}//增加字符串

清理

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

插入

void insert(size_t pos, char ch)
{if (_size == _capacity){reserve(_capacity = 0 ? 4 : 2 * _capacity);}int end = _size + 1;for (int i = end; i > pos; i--){_str[end] = _str[end - 1];}_str[pos] = ch;++_size;
}//插入

运算符重载运算

字符串直接增加

string& operator+=(char ch)
{push_back(ch);return *this;
}//增加字符
string& operator+=(const char* str)
{append(str);return *this;
}//增加字符串

各种比较

bool operator<(const string& s)const//比较
{return strcmp(_str, s._str)<0;
}
bool operator==(const string& s)const
{return strcmp(_str, s._str) == 0;
}
bool operator<=(const string& s)const
{return ( * this < s) || ( * this == s);
}
bool operator>=(const string& s)const
{return !(*this < s);
}
bool operator>(const string& s)const
{return !(*this <= s);
}
bool operator!=(const string& s)const
{return !(*this == s);
}

流插入/流提取

注意，这里为了能够多次流提取，就用get()函数——也就是getchar() 来读取空格

ostream& operator<<(ostream& out, const string& s)
{for (int i = 0; i < s.size(); i++){out << s[i];}return out;
}istream& operator>>(istream& in, string& s)//流提取
{s.clear();//先进行处理char ch;ch = in.get();//一个字符一个字符地拿while (ch != ' ' && ch != '\n'){s += ch;//附上ch = in.get();}return in;
}

特定位置的数据清理

void 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;whlie(begin<=_size){_str[begin-len]=_str[begin];++begin;}}_size-=len;
}

进行字符串的提取

string substr(size_t pos,size_t len=npos)
{string s;size_t end=pos+len;if(len==npos||end>=_size){len=_size-pos;//如果到末尾，那么取的字符就是剩下的全部end=_size;//最后一个数据则直接取到末尾即可}s.reserve(len);for(size_t i=pos;i<_size;i++){s+=(_str[i]);}return s;
}

查找函数

//查找字符
size_t find(char ch, size_t pos=0)
{for(size_t i=0;i<_size;i++){if(_str[i]==ch){return i;//返回下标}}return npos;
}//字符串
size_t find(const char* sub, size_t pos = 0)
{const char* p=strstr(_str,sub);//用ststr函数，恰好满足find函数的要求，kmp过于复杂if(p){return p-_str;}else{return npos;}
}

重新定义大小size

void resize(size_t n, char ch = '\0')
{if(n<=_size){_str[n]='\0';}else{reserve(n);while(_size<n)//从_size一直到n都输入想要输入的字符{_str[_size]=ch;++_size;}_str[_size]='\0';}
}

拷贝构造

//用一个交换函数来实现数据的交换，且为了不改变原对象，所以用一个中间载体来实现交换
void swap(string& s)
{std::swap(_str,s._str);std::swap(_size,s._size);std::swap(_capacity,s,_capacity);
}string(const string& s):_str(nullptr),_size(0),_capacity(0)
{string tmp(s._str);swap(tmp);
}

赋值拷贝

string& operator=(const string& s)
{if (this != &s)//异地拷贝，就是不共用同一个空间{char* tmp = new char[s._capacity + 1];strcpy(tmp, s._str);delete[]_str;_str = tmp;_size = s._size;_capacity = s._capacity;}return *this;
}

改进

对赋值拷贝改进

string& operator=(string tmp)//用形参接收要拷贝的对象
{swap(tmp);//将中间载体与目标进行交换return *this;//返回即可
}

这样实现了定义了中间载体tmp的同时，用tmp接受了要拷贝的内容，然后直接进行交换，返回拷贝的对象。

对流提取的改进

我们知道，在进行流提取的时候，一旦内存满了，那我们就需要开辟空间，在输入初期需要多次重新开辟扩大空间，那有什么方法可以减少扩大空间的次数？——用一个数组作为暂时存放的缓冲器。

istream& operator>>(istream& in, string& s)//流提取
{s.clear();//先进行处理char buff[129];//用一个数组进行数据的传递和存放size_t i = 0;char ch;ch = in.get();//一个字符一个字符地拿while (ch != ' ' && ch != '\n'){buff[i++] = ch;if (i == 128)//此时满了{buff[i] = '\0';s += buff;i == 0;//重置为0}ch = in.get();}if (i != 0){buff[i] = '\0';s += buff;}return in;
}