1. 标准库中的string类

1. 字符串是表示字符序列的类
2. 标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字字节字符字符串的设计特性
3. string类是使用的char
4. string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_string的默认参数
5. 注意，这个类独立于所使用的编码来处理字节；如果用来处理多字节或变长字符的序列，这个类的所有成员以及它的迭代器，将仍按照字节来操作

总结：

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

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

2. string类的常用接口说明

2.1. string类对象的常见构造

2.2. string类对象的容量操作

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

2.4. string类对象的修改操作

2.5. string类的非成员函数

3. string的模拟实现

// 细节全在代码里了，相信对大家不成问题
#include 
using namespace std;
#include 
#include 
namespace smk
{class string{public:typedef char* iterator;iterator begin(){return _ptr;}const iterator begin()const{return _ptr;}iterator end(){return _ptr + size();}const iterator end()const{return _ptr + size();}char* c_str(){return _ptr;}string(const char* ptr = ""){_size = strlen(ptr);_capacity = _size;_ptr = new char[_capacity + 1];strcpy(_ptr, ptr);}size_t size() const{return _size;}size_t capacity() const{return _capacity;}//普通对象char& operator[](size_t pos){assert(pos < _size);return _ptr[pos];}//const对象const char& operator[](size_t pos) const{assert(pos < _size);return _ptr[pos];}void reserve(size_t n){if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _ptr);delete[] _ptr;_ptr = tmp;_capacity = n;}}void swap(string& s){std::swap(_ptr, s._ptr);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}//s1(s2)//传统写法/*string(const string& s){_ptr = new char[s._capacity + 1];_size = s._size;_capacity = s._capacity;strcpy(_ptr, s._ptr);}*///s1(s2)//现代写法string(const string& s):_ptr(nullptr),_size(0),_capacity(0){string tmp(s._ptr);swap(tmp);}/*string& operator=(const string& s){if (this != &s){char* tmp = new char[s._capacity + 1];delete[] _ptr;_ptr = tmp;_size = s._size;_capacity = s._capacity;}return *this;}*///s1 = s2 现代写法string& operator=(string s){swap(s);return *this;}void push_back(char ch){if (_size == _capacity){int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;reserve(newcapacity);}_ptr[_size] = ch;++_size;_ptr[_size] = '\0';}string& append(const char* ptr){int len = strlen(ptr);if (_size + len > _capacity){reserve(_size + len);}strcpy(_ptr + _size, ptr);_size += len;return *this;}string& operator+=(const char* ptr){append(ptr);return *this;}string& operator+=(char ch){push_back(ch);return *this;}void clear(){_size = 0;_ptr[_size] = '\0';}string& insert(size_t pos, const char ch){assert(pos < _size);size_t end = _size + 1;while (end > pos){_ptr[end] = _ptr[end - 1];--end;}_ptr[pos] = ch;++_size;_ptr[_size] = '\0';return *this;}string& insert(size_t pos, const char* ptr){assert(pos < _size);int len = strlen(ptr);if (_size + len > _capacity){reserve(_size + len);}size_t end = _size + len;while (end > pos + len - 1){_ptr[end] = _ptr[end - len];--end;}strncpy(_ptr + pos, ptr, len);_size += len;return *this;}~string(){delete[] _ptr;_ptr = nullptr;_size = _capacity = 0;}string& erase(size_t pos, size_t len = npos){assert(pos < _size);if (len == npos || len > _size - pos){_ptr[pos] = '\0';_size = pos;}else{size_t start = pos + len;while (start <= _size){_ptr[start - len] = _ptr[start];++start;}_size -= len;}return *this;}size_t find(char ch, size_t pos = 0) const{assert(pos < _size);for (size_t i = pos; i < _size; ++i){if (_ptr[i] == ch){return i;}}return npos;}size_t find(const char* ptr, size_t pos = 0) const{assert(pos < _size);const char* tmp = strstr(_ptr + pos, ptr);if (tmp == nullptr){return npos;}return tmp - _ptr;}void resize(size_t n ,char ch = '\0'){if (n > _size){reserve(n);for (size_t i = _size; i < n; ++i){_ptr[i] = ch;}_size = n;_ptr[_size] = '\0';}else{_ptr[n] = '\0';_size = n;}}private:char* _ptr;size_t _size;size_t _capacity;const static size_t npos = -1;};ostream& operator<<(ostream& out, const string& s){for (size_t i = 0; i < s.size(); ++i){out << s[i];}return out;}istream& operator>>(istream& in, string& s){s.clear();char buffer[128] = { '\0' };char ch = in.get();int i = 0;while (ch != ' ' && ch != '\n'){if (i == 127){s += buffer;i = 0;}buffer[i++] = ch;ch = in.get();}if (i > 0){buffer[i] = '\0';s += buffer;}return in;}