【C++】string 的使用和模拟实现

string类对象的常见构造：

如何初始化类的对象是由类本身决定的。一个类可以定义很多种构造函数。当然每种构造函数在在初始值得数量或者类型都有差别（函数重载）。

string() 构造空的string类对象，即空字符串 string(const char* s) 用C-string来构造string类对象 string(size_t n, char c) string类对象中包含n个字符c string(const string&s) 拷贝构造函

string s0;//默认初始化，s0是一个空字符串 string s1("hello world");//用字面值"hello world"，构造s1 string s2(s1);//用s1拷贝构造 s2 string s3 = s2;//等价于s3(s2),用s2拷贝构造s3 //先用字面值"hello world"构造一个string类型的临时对象，再用临时对象拷贝构造s4. string s4 = "hello world"; string s5(10,'c');//将s5初始化为，由10个字符'c'组成的串

读写string对象：

（1）用IO操作符（<<,>>）读写string对象

我们可以使用标准库的iostream来读写int,double，等内置类型。也可以在string类里边通过运算符重载的方式，用IO操作符（<<,>>）读写string对象。

int main(){ string s; //空字符串 cin >> s;//将string 对象读入s遇到空白停止 cout << s << endl;//输出s retrun 0; }

需要注意的是：在文件读取时，string类对象会忽略所有的空白（空格符，换行符，制表符等），从的一个真正的字符开始到空白结束。 所以程序输入的如果是" Hello world".输出的将会是"Hello"。

在运算符>> 和 << 重载时函数的返回值是运算符左侧的操作对象。所以所以多个输入或者输出可以连在一起：

int main(){ sting s1,s2;//定义两个空字符串 cin >> s1 >> s2;// 把第一个串读到s1中，第二个读到s2中 cout << s1 << s2 << endl;//输出 }

如果这次依然输入" Hello world" 输出为“Helloword“ （2）使用getline读取一整行： istream& getline (istream& is, string& str); 有时候我们希望等在最终得到的字符串中，保留空白符。这时应该用getline函数代替>>运算符。函数从输入流is中读入内容到str中，直到遇到换行为止。geline只要一遇到换行符就结束读取操作并返回结果。如果一开始就输入换行符，那么就会得到一个空的sting对象。 getline也会返回他的流参数，因此可以使用getline的结果作为条件：

int main(){ string s0;//定义一个空串 //读入未知个string对象，每次读入一整行，直到文件的结束 while( getline(s0) ) cout<< s0 << endl; return 0; }

关于容量的操作：

size_t size() const;返回字符串有效字符长度。 size_t length() const;返回字符串有效字符长度 size_t capacity() const; 返回空间总大小 bool empty() const; 检测字符串释放为空串，是返回true，否则返回false void clear(); 清空有效字符 ，clear仅在逻辑层面进行数据清理，而不会进行内存释放。 void reserve (size_t n = 0);为字符串预留空间。 void resize (size_t n); void resize (size_t n, char c);将有效字符的个数该成n个，多出的空间用字符c填充 需要注意的是：

size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一 致，一般情况下基本都是用size()。

clear()只是将string中有效字符清空，不改变底层空间大小,只是将对象的_size置为0。

resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不同的是当字 符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char c)用字符c来填充多出的元素空间。操作后string对象有效元素的多少改变成了n。

reserve(size_t res_arg=0)：为容器预留足够的空间，避免不必要的重复分配。不改变有效元素个数，当reserve的参数小于 string的底层空间总大小时，容器不会发生任何改变。如果大于将底层空间，则扩容。而对象有效元素的多少始终不发生改变。 关于size_t 和 size_type:

标准定义中，size_t和size_type被定义为unsigned int。但是sizt_t是C++的一个标准的typedef，全局有效，定义在全局名称空间中,size_type是STL定义的，size_t不是容器概念，而size_type是容器概念，没有容器不能使用。

size_t的引入增强了程序在不同平台上的可移植性。经测试发现，在32位系统中size_t是4字节的，而在64位系统中，size_t是8字节的，这样利用该类型可以增强程序的可移植性。

处理string对象中的字符：

（1）使用范围for处理对象的每个字符；

c++11新标准提供了一种语句：范围for语句。这种语句遍历给定序列的每个元素

string str("Hello world"); for (auto a : str ) cout << c << endl;//输出当前字符，并换行

范围for把变量a 和 序列 str联系起来。auto是让编译器确定a的类型，a的类型是char。每次循环将序列的下一个字符拷贝给变量a，然后输出。但是如果在范围for中修改str序列，上边变量的定义显然是不行的，因为每次循环都只是将str的字符拷贝一份给变量a。所以如果要改变序列str，就应该把循环变量定义成引用类型：

string str("Hello world"); for (auto &a : str ) a = 'H';//将str序列的每个字符换成'H' cout << str << endl;

（2）用下标运算符[],处理string对象某个字符：

string s0 = "hello"; for(size_t i = 0; i < s0.size(); i++){ cout << s0[i]; } cout << endl;

string对象的下标必须大于等于0,而小于s.size()。使用超出此范围的下标将引发不可预知的结果，以此推断，使用下标访问空string会引发不可预知的结果。 （3）用迭代器处理string对象的某个字符：

最常见的迭代器： string s = "hello"; string::iterator it = s.begin(); while( it != s.end() ){ cout<< *it <<" "; ++it; } cout << endl;

需要注意的是，s.begin()是‘h’，但是s,end()是最后一个 字符’o’的下一个位置。

反向迭代器： string s = "hello"; string :: reverse_iterator it = s.rbegin(); while( it != s.rend() ){ cout<< *it <<" "; ++it; } cout << endl;

程序会输出: o l l e h

const迭代器; const string s = "hello"; string :: const_iterator it = s.begin(); while( it != s.end() ){ cout<< *it <<" "; ++it; } cout << endl;

string类对象的修改操作

（1）尾插一个字符 void push_back (char c);在字符串后尾插字符c （2）尾插一个字符串。 string& append (const string& str)；//str的所有内容，拼接到对象的后边 string& append (const string& str, size_t subpos, size_t sublen);//str字符串从subpos开始共sublen位拼接到对象后边。 string& append (const char* s);//将c格式的字符串拼接到，对象的后边。 string& append (const char* s, size_t n);//字符串的前 n、位拼接到对象后边。 string& append (size_t n, char c);// 将5个字符c拼接到，对象后边。 （3）在字符串后追加字符串str string& operator+= (const string& str); string& operator+= (const char* s); string& operator+= (char c); （4）返回C格式字符串 const char* c_str() const noexcept; c_str()函数返回一个指向正规C字符串的指针常量, 内容与本string串相同。这是为了与c语言兼容，在c语言中没有string类型，故必须通过string类对象的成员函数c_str()把string 对象转换成c中的字符串样式。 注意：一定要使用strcpy()函数 等来操作方法c_str()返回的指针 （5）从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置 size_t find (const string& str, size_t pos = 0) const; //查找对象–string类对象 size_t find (const char* s, size_t pos = 0) const; //查找对象–字符串 size_t find (const char* s, size_t pos, size_t n) const; //查找对象–字符串的前n个字符 size_t find (char c, size_t pos = 0) const; //查找对象–字符 找到 – 返回 第一个字符的索引，没找到–返回 string::npos(代表 -1 表示不存在) （6）在str中从pos位置开始，截取n个字符，然后将其返回 string substr (size_t pos = 0, size_t len = npos) const;

模拟实现string类

（1）实现一个简单的string类包括 构造 拷贝构造 赋值运算符重载 析构 reserve(szie_t) push_back(char) 等

namespace LZH{ struct string{ string(char* str = ""){//构造 _size = strlen(str); _capacity = _size; _str = new char[_capacity + 1]; strcpy(_str, str);//strcpy 会连'\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){//拷贝构造 string tem(s._str); swap(tem); } ~string(){//析构 delete[] _str; _str = nullptr; _size = _capacity = 0; } string& operator=(string s){//赋值运算符重载 先调用拷贝构造初始化形参 swap( s ); return *this; } void reserve(size_t newcapacity){ if (newcapacity <= _capacity){ return; } char* newstr = new char[newcapacity + 1]; strcpy(newstr, _str); delete[] _str; _capacity = newcapacity; _str = newstr; } void push_back(char c){ if (_size == _capacity){//扩容 int newcapacity = _capacity == 0 ? 1 : 2 * _capacity; reserve(newcapacity); } _str[_size++] = c; _str[_size] = '\0'; } private: size_t _size; size_t _capacity; char* _str; static size_t npos; }; size_t string :: npos = -1; }//namespace LZH

（2）具体实现： https://github.com/WhynotHH/Simulate-STL/blob/master/string.h