目录

String的常用接口说明(最常用的)

 string类对象的容量操作

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

string类对象的修改操作

 string类非成员函数 

深浅拷贝

简介：C++string 是C++中的字符串。 字符串对象是一种特殊类型的容器，专门设计来操作的字符序列。 不像传统的c-strings,只是在数组中的一个字符序列，我们称之为字符数组，而C + +字符串对象属于一个类，这个类有很多内置的特点，在操作方式，更直观，另外还有很多有用的成员函数。 string 的定义为：typedef basic_string string。

String的常用接口说明(最常用的)

下面是对常用接口的模拟：

构造函数

namespace my_string
{class string{public:string(const char* str = "") //构造函数{                            //构造函数可以是缺省的 _size = strlen(str);     //当没有传初始化值的时候默认初始化成空串_capacity = _size;_str = new char[_capacity + 1];}private:char* _str;//字符串size_t _capacity;//容量size_t _size;//大小public:const static int npos = -1;};
}

拷贝构造函数

namespace my_string
{class string{public:string(const string& s)     //拷贝构造函数:_str(new char[s._capacity + 1]) //是用一个string类去初始化宁一个string类              , _size(s._size) , _capacity(s._capacity){strcpy(_str, s._str); //s._str复制到_str}void swap(string &tmp){::swap(_str, tmp._str);//这里使用::是使用c++库中的swap函数::swap(_size, tmp._size);::swap(_capacity, tmp._capacity);}string(const string& s)//要把string类s 给 _str 所以要清除_str:_str(nullptr),_size(0),_capacity(0){string tmp(s._str);swap(tmp);}private:char* _str;//字符串size_t _capacity;//容量size_t _size;//大小public:const static int npos = -1;};
}

这里第一个是普通写法，第二个是打工人写法，首先要知道我们模拟的string类中有一个保存字符串的私有成员：_str 这时候要给_str赋值可以先建立一个打工人tmp 用 传过来的string类s来调用构造函数来构造tmp，再交换tmp和_str的各项的数值。

注意 ：如果String类没有显式定义其拷贝构造函数与赋值运算符重载，此时编译器会生成默认的，当用s1构造s2时，编译器会调用默认的拷贝构造。最终导致的问题是，s1、s2共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。

析构函数

~string()
{delete[] _str;_str = nullptr;_size = _capacity = 0;
}

 string类对象的容量操作

namespace my_string
{class string{size_t size()const            //由于length跟size一个性质 就实现size{return _size;} size_t capacity()const        //返回my_string类中私有成员_capacity{return _capacity;}bool empty()const{return _size == 0;        //如果_size为0代表有效字符为0 字符串为空}void clear()                  {_str[0] = '\0';           //清除my_string中的有效字符，但容量不变_size = 0;}void reserve(size_t n)        //给函数扩容n个{if (_capacity < n)        //如果输入的n小于_capacity就不扩容{char* tmp = new char[n + 1];//有效字符为n开n+1是为了给'\0'留个位置_size = n;_capacity = n;strcpy(tmp, _str);delete[] _str;_str = tmp;}}void resize(size_t n, char c = '\0')//调整容器的有效数量 hello {if (n <= _capacity)//截取 小于等于 容量{_str[n] = '\0';}else {reserve(n);                    //扩容_capacity = n;for (int i = _size; i < n; i++)//填充{push_back(c);//尾插}}}private:char* _str;//字符串size_t _capacity;//容量size_t _size;//大小public:const static int npos = -1;};
}

注意：

 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的参数小于string的底层空间总大小时，reserver不会改变容量大小

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

namespace my_string
{class string{public:char& operator[](size_t index)   //重载[]{assert(index < _size);return _str[index];}const char& operator[](size_t index)const{assert(index < _size);return _str[index];}typedef char* iterator;          //iterator就是char* 类型的指针      typedef const char* const_iterator; //const_iterator就是 const char* 类型的指针const_iterator begin() const{return _str;}const_iterator end() const{return _str + _size;}iterator begin(){return _str;}iterator end(){return _str + _size;}private:char* _str;//字符串size_t _capacity;//容量size_t _size;//大小public:const static int npos = -1;};
}

string类对象的修改操作

namespace my_string
{class string{public:void push_back(char c){if (_size == _capacity) //日常检测空间满了没有{reserve(_capacity == 0 ? 4 : 2 * _capacity);//调用reserve开空间}_str[_size] = c;_size++;_str[_size] = '\0';}void append(const char* str) //追加字符串{int len = strlen(str);if (len + _size > _capacity)//老规矩检查容量{reserve(len + _size);}strcpy(_str+_size, str);_size += len;}string& operator+=(const char* str){append(str);   //直接复用return *this;  //返回是为了可以连续+= a+=b+=c}const char* c_str()const{return _str;   //返回字符串(返回的是char*)}size_t find(char c, size_t pos = 0) const //返回的是第一次找到字符c的位置{for (int i = 0; i < _size; i++){if (_str[i] == 'c')return i;}return npos;        //没找到返回npos值为-1}size_t find(const char* s, size_t pos = 0) const //返回字符串第一次出现的位置{const char* ptr = strstr(_str + pos, s); //c库中找子串的函数if (ptr == nullptr){return npos;}else {return ptr - _str; //指针相减得出位置}}private:char* _str;//字符串size_t _capacity;//容量size_t _size;//大小public:const static int npos = -1;};
}

 string类非成员函数 

namespace my_string
{class string{public:string& operator+(const char* str){string tmp(*this);tmp += str;return tmp;}friend ostream& operator<<(ostream& _cout, const my_string::string& s);friend istream& operator>>(istream& _cin, gch::string& s);bool operator<(const string& s){return strcmp(_str, s._str) < 0;}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);}bool operator==(const string& s){return strcmp(_str, s._str) == 0;}bool operator!=(const string& s){return !(_str == s._str);}private:char* _str;//字符串size_t _capacity;//容量size_t _size;//大小public:const static int npos = -1;};
}ostream& operator<<(ostream& _cout, const my_string::string& s)
{for (size_t i = 0; i < s.size(); i++){_cout << s[i]; //_cout就是输出流里cout的别名 下面cin同理}return _cout;
}istream& operator>>(istream& _cin, my_string::string& s)
{for (size_t i = 0; i < s.size(); i++){_cin >> s[i];}return _cin;
}

深浅拷贝

浅拷贝 ：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规

图中为浅拷贝，s1和s2指向同一块空间

深拷贝：如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供

图中为深拷贝s1与s2分别指向不同的的空间。