下面进行模拟实现

size_t size()const
{return _size;
}
size_t capacity()const
{return _capacity;
}
const char* c_str()
{return _str;
}
void reserve(size_t n)
{if (_capacity < n){char* tmp = new char[n + 1];strcpy(tmp, _str);//防止将_str删除出现错误，先对其进行保存delete[] _str;_str = tmp;_capacity = n;}/*char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;*/
}
//分为三种情况
//一是小于——size,二是大于_size但是并不需要扩容，三就是大于_size还需要扩容
void resize(size_t n, char ch = '\0')//缺省参数
{if (n <= _size){_str[_size] = '\0';_size = n;}else{if (n > _capacity){reserve(n);}size_t i = _size;while (i < n){_str[i++] = ch;}_size = n;_str[_size] = '\0';}
}
void clear()
{_str[0] = '\0';_size = 0;
}

注意：

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的底层空间总大小时，reserve不会改变容量大小。

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

void func(const string& s)
{//权限扩大//string::const_reverse_iterator rit = s.rbegin();auto rit = s.rbegin();while (rit != s.rend()){cout << *rit << " ";rit++;}
}
int main()
{string s("hello world");string::iterator it = s.begin();while (it != s.end()){cout << *it << " ";it++;}cout << endl;for (auto it : s){cout << it << " ";}string s1("hello world");string::reverse_iterator rit = s1.rbegin();while (rit!=s1.rend()){cout << *rit << " ";rit++;}cout << endl;func(s1);//s1[100];s1.at(100);return 0;
}

在这里也可以了解一下at

int main ()
{std::string str ("Test string");for (unsigned i=0; istd::cout << str.at(i);}return 0;
}

进行模拟实现

typedef char* iterator;
typedef const char* const_iterator;
iterator begin()
{return _str;
}
iterator end()
{return _str + _size;
}
const_iterator begin()const
{return _str;
}
const_iterator end()const
{return _str + _size;
}
const char& operator[](size_t pos)const
{assert(pos < _size);return _str[pos];
}
char& operator[](size_t pos)
{assert(pos < _size);return _str[pos];
}

因为范围for是有迭代器实现的所以，实现了迭代器就相当于实现了范围for
将范围for的begin改成Begin就会行不通了，范围for是傻瓜

string类对象的修改操作

int main()
{string s1("hello world");s1.push_back('#');cout << s1 << endl;s1.append("***");cout << s1 << endl;s1 += '@';cout << s1 << endl;s1 += "&&";cout << s1 << endl;string s2("hello world");s2 += '\0';s2 += "###";cout << s2 << endl;cout << s2.c_str() << endl;cout << s2.find('o') << endl;cout << s2.rfind('o') << endl;cout << s2.substr(2,3) << endl;return 0;
}

模拟实现

void push_back(char c)
{/*if (_size + 1 > _capacity){reserve(_capacity * 2);}_str[_size] = c;_size++;_str[_size] = '\0';*/insert(_size, c);
}
void append(const char* a)
{//size_t length = strlen(a);//if (_size + length > _capacity)//{//	reserve(_size + length);//}//strcpy(_str + _size, a);strcat(_str,a);虽然这里也能用，//但是是在C语言没办法时，而这里我们是知道\0的位置的，//strcat是找到\0然后进行插入，而这里是知道\0的位置的，所以能不用就不用strcat//_size += length;insert(_size, a);
}
//swap(s1,s2);
//s1.swap(s2);
//为什么下面的交换更加的快捷。是因为上面的要进行三次深拷贝，
//而下面就只是需要进行三次浅拷贝
void swap(string& s)
{std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);
}
size_t find(char a, size_t pos = 0)
{assert(pos < _size);for (size_t i = pos; i < _size; i++){if (_str[i] == a){return i;}}return npos;
}
size_t find(const char* str, size_t pos = 0)
{assert(pos < _size);char* p = strstr(_str + pos, str);if (p == nullptr){return npos;}else{return (p - _str);}return npos;
}
string& operator+=(const char c)
{push_back(c);return (*this);
}
string& operator+=(const char* a)
{append(a);return (*this);
}
void insert(size_t pos, char ch)
{assert(pos <= _size);if (_size + 1 > _capacity){reserve(_capacity * 2);}size_t end = _size + 1;while (end > pos)//注意当end等于负数时会出错，会整型提升{_str[end] = _str[end - 1];end--;}_str[pos] = ch;_size += 1;
}
void insert(size_t pos, const char* str)
{assert(pos <= _size);size_t length = strlen(str);if (_size + length > _capacity){reserve(_size + length);}size_t end = _size + length;while (end > pos + length - 1)//注意当end等于负数时会出错，会整型提升{_str[end] = _str[end - length];end--;}size_t i = 0;while (length > 0){_str[pos++] = str[i++];length--;}//_str[pos] = ch;_size += length;
}
void erase(size_t pos, size_t length = npos)
{assert(pos < _size);if (length == npos || pos + length > _size){_str[pos] = '\0';}else{strcpy(_str + pos, _str + pos + length);_size -= length;}}

注意：

1. 在string尾部追加字符时，s.push_back© / s.append(1, c) / s += 'c’三种的实现方式差不多，一般情况下string类的+=操作用的比较多，+=操作不仅可以连接单个字符，还可以连接字符串。
2. 对string操作时，如果能够大概预估到放多少字符，可以先通过reserve把空间预留好。

string类非成员函数

int main()
{string s;getline(cin,s);cout << s << endl;string firstlevel("com");string secondlevel("cplusplus");string scheme("http://");string hostname;string url;hostname = "www." + secondlevel + '.' + firstlevel;url = scheme + hostname;cout << url << '\n';
}

模拟实现

//swap(s1,s2);
//s1.swap(s2);
//为什么下面的交换更加的快捷。是因为上面的要进行三次深拷贝，
//而下面就只是需要进行三次浅拷贝
void swap(string& s)
{std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);
}
//下面采用复用，会省好多事情
bool operator>(string& s)const
{return strcmp(_str, s._str) > 0;
}
bool operator==(string& s)const
{return strcmp(_str, s._str) == 0;
}
bool operator>=(string& s)const
{return (*this) > s || (*this) == s;
}
bool operator<(string& s)const
{return !((*this) >= s);
}
bool operator<=(string& s)const
{return !((*this) > s);
}
bool operator!=(string& s)const
{return !((*this) == s);
}ostream& operator<<(ostream& out, const string& s)
{for (auto ch : s){out << ch;}return out;
}
istream& operator>>(istream& in, string& s)
{s.clear();char ch = in.get();char buff[128];size_t i = 0;while (ch != ' ' && ch != '\n'){buff[i++] = ch;if (i == 127){//写满将内容导入buff[127] = '\0';s += buff;i = 0;}ch = in.get();}//原理是将buff一段一段的导入if (i != 0){//在判断是否需要将buff导入buff[i] = '\0';s += buff;}return in;
}