C++ string模拟实现
C++的string类是一个类模板，用于表示和操作任何字符类型的字符串。 string类内部使用字符数组来存储字符，但是所有的内存管理，分配和空终止都由string类自己处理，所以使用起来很方便。string类的长度可以在运行时改变，因为它使用动态内存分配类似于vector。
string类提供了许多成员函数和运算符重载，用于进行字符串的创建，赋值，连接，比较，查找，替换，插入，删除等操作。你可以使用下标运算符[]或at()函数来访问字符串中的单个字符。你也可以使用c_str()或data()函数来获取字符串的C风格表示形式。
string模拟实现（部分接口）
官方C++string类：(string)
#define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> #include<string> using namespace std; #include <assert.h> namespace hsl { class string { public: typedef char* iterator; //构造函数 string(const char* str = "") :_size(strlen(str)) , _capacity(_size) { _str = new char[_capacity + 1]; strcpy(_str, str); } //string(const string& s); //string& operator=(const string& s); //析构函数 ~string() { delete[] _str; _str = nullptr; _size = _capacity = 0; } // // iterator //返回第一个位置的指针 iterator begin() { return _str; } //返回最后一个位置的指针 iterator end() { return _str + _size; } / // modify //尾插字符 void push_back(char c) { if (_size == _capacity) { reserve(_capacity == 0 ? 4 : _capacity * 2); } _str[_size] = c; _size++; _str[_size] = '\0'; } //尾插字符 string& operator+=(char c) { push_back(c); return *this; } //尾插字符串 void append(const char* str) { size_t len = strlen(str); if (_size + len > _capacity) { reserve(_size + len); } strcpy(_str + _size, str); _size += len; } //重载+=运算符（尾插字符串） string& operator+=(const char* str) { append(str); return *this; } //void clear(); //void swap(string& s); //以字符串的形式返回 const char* c_str()const { return _str; } / //返回数据个数 size_t size()const { return _size; } //返回容量大小 size_t capacity()const { return _capacity; } //判断是否为空 bool empty()const { return (_size == 0 || _capacity == 0); } //如果 n 小于当前容器大小，则内容将减少到其前 n 个元素，删除超出的元素（并销毁它们）。 //如果 n 大于当前容器大小，则通过在末尾插入所需数量的元素来扩展内容，以达到 n 的大小。如果指定了 //val，则新元素将初始化为 val 的副本，否则，它们将被值初始化。 //如果 n 也大于当前容器容量，则会自动重新分配分配的存储空间。 void resize(size_t n, char c = '\0') { if (n < _size) { _str[_size] = c; _size = n; } if (n > _size) { if (n > _capacity) { reserve(n); } int x = _size; _size = n; while (x < n) { _str[x] = c; x++; } _str[n] = '\0'; } } //扩容 void reserve(size_t n) { if (n > _capacity) { char* ch = new char[n + 1]; strcpy(ch, _str); delete[] _str; _str = ch; _capacity = n; } } / //[]重载运算符 char& operator[](size_t index) { assert(index < _size); return _str[index]; } //[]重载运算符(重载函数) const char& operator[](size_t index)const { assert(index < _size); return _str[index]; } / //relational operators //<重载运算符 bool operator<(const string& s) { return strcmp(_str, s._str) < 0; } //<=重载运算符 bool operator<=(const string& s) { return (_str < s._str) || (_str == s._str); } //>重载运算符 bool operator>(const string& s) { return !((_str <= s._str)); } //>=重载运算符 bool operator>=(const string& s) { return !(_str < s._str); } //==重载运算符 bool operator==(const string& s) { return strcmp(_str, s._str) == 0; } //！=重载运算符 bool operator!=(const string& s) { return !(_str == s._str); } // 返回c在string中第一次出现的位置 //size_t find(char c, size_t pos = 0) const; // 返回子串s在string中第一次出现的位置 //size_t find(const char* s, size_t pos = 0) const; // 在pos位置上插入字符c/字符串str，并返回该字符的位置 string& insert(size_t pos, char c) { assert(pos <= _size); if (_size == _capacity) { reserve(_capacity == 0 ? 4 : _capacity * 2); } int end = (int)_size; while (end >= (int)pos) { _str[end + 1] = _str[end]; --end; } _str[pos] = c; _size++; return *this; } //在pos位置插入字符串 string& insert(size_t pos, const char* str) { assert(pos <= _size); int len = strlen(str); if (_size + len > _capacity) { reserve(_size + len); } int end = _size; while (end >= (int)pos) { _str[end + len] = _str[end]; --end; } _size += len; int n = pos + len; int i = 0; while (pos < n) { _str[pos++] = str[i++]; } return *this; } // 删除pos位置上的元素，并返回该元素的下一个位置 string& erase(size_t pos, size_t len) { assert(pos < _size); size_t end = _size; //assert((end - pos) >= len); if (pos + len >= _size) { _str[pos] = '\0'; _size = pos; } else { while (pos <= (end - len + 1)) { _str[pos] = _str[pos + len]; pos++; } _size -= len; } return *this; } //清空数据（不删除数据） void clear() { _str[0] = '\0'; _size = 0; } //传统写法 s1(s2) //string(const string& s) //{ // _str = new char[s._capacity + 1]; // strcpy(_str, s._str); // _size = s._size; // _capacity = s._capacity; //} s1 = s2; //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; //} //交换 void swap(string& s) { std::swap(_str, s._str); std::swap(_size, s._size); std::swap(_capacity, s._capacity); } //s1(s2) //拷贝构造 string(const string& s) :_str(nullptr) , _size(0) , _capacity(0) { string tmp(s._str); swap(tmp); } //s1 = s2; //赋值重载 string& operator=(string s) { swap(s); return *this; } private: char* _str;//字符指针 size_t _size;//字符个数 size_t _capacity;//容量 }; //输出流 ostream& operator<<(ostream& _cout, const string& s) { for (size_t i = 0; i < s.size(); i++) { cout << s[i]; } return _cout; } //istream& operator>>(istream& _cin, string& s) //{ // s.clear(); // char ch; // ch = _cin.get(); // while (ch != ' ' && ch != '\n') // { // s += ch; // ch = _cin.get(); // } // return _cin; //} //输入流 istream& operator>>(istream& _cin, string& s) { s.clear(); char ch; char buff[129]; int i = 0; ch = _cin.get(); while (ch != ' ' && ch != '\n') { buff[i++] = ch; if (i == 128) { buff[i] = '\0'; s += buff; i = 0; } ch = _cin.get(); } if (i != 0) { buff[i] = '\0'; s += buff; } return _cin; } void test_string3() { string s1; cin >> s1; cout << s1 << endl; cout << s1.size() << endl; cout << s1.capacity() << endl; } } int main() { hsl::test_string3(); return 0; }
（本章完）
