c++string类实现（现代写法与传统写法）

标准库中的string类：

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

---

string类的常用构造函数

• string() 构造空的string类对象
• string(const char* s) 用C风格字符串来构造string对象
• string(size_t n,char c) string类对象中包含n个字符c
• string(const string&s) 拷贝构造
• string(const string&s,size_t n) 用s中前n个字符构造新的string对象

string类的常用容量操作

• size_t size() const 返回字符串有效字符长度
• size_t length() const 返回字符串有效字符长度
• size_t capacity() const 返回容量大小
• bool empty() const 检测字符串是否为空串，是返回true，否则返回false
• void clear() 清空有效字符
• void resize(size_t n,char c) 将有效字符的个数改成n个，多出的空间用字符c填充
• void resize(size_t n) 将有效字符的个数改成n个，多出的空间用0填充

注意：

• size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接口保持一致，一般情况下用size().
• clear()只是将string中有效字符清空，不改变容量大小
• resize(size_t n)与resize(size_t n,char c)都是将字符串中有效字符个数改变到n个不同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n,char c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数增多，可能会改变容量的大小，如果是将元素个数减少，容量大小不变
• reserve(size_t res_arg = 0):为string预留空间，不改变有效元素个数，当reserve的参数小于string的底层空间总大小时，reserve不会改变容量大小。

string类的常用修改操作

• void push_back(char c) 在字符串后尾插字符c
• string& append(const char* s) 在字符串后追加一个字符串
• string& operator+=(const string& str) 在字符串后追加字符串str
• string& operator+=(const char*s) 在字符串后追加C格式字符串
• string& operator+=(char c) 在字符串后追加字符c
• const char* c_str() const 返回C格式字符串
• size_t find(char c,size_t pos=0) const 从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置
• size_t rfind(char c,size_t pos = npos) 从字符串pos位置开始往前找字符c，返回该字符在字符串中的位置
• string substr(size_t pos=0,size_t n=npos) const 在str中从pos位置开始，截取n个字符，然后将其返回

string类的实现

首先是成员变量：

class String{
   
private:
	char* _str;//字符串
	size_t _size;//有效字符
	size_t _capacity;//容量
};

构造函数

	//无参构造
	String()
		:_str(new char[16])
		, _size(0)
		, _capacity(15)
	{
   
		_str[0] = '\0';//空字符串
	}
	//带参构造
	String(const char* str)
	{
   
		_size = strlen(str);
		_str = new char[_size + 1];/开空间
		strcpy(_str, str);//拷贝内容
		_capacity = _size;//这里让容量等于有效字符数
	}

拷贝构造

传统写法：

	//拷贝构造(深拷贝)
	String(const String& str)
		:_str(new char[str._capacity + 1])//开空间初始化
		, _size(str._size)
		, _capacity(str._capacity)
	{
   
		strcpy(_str, str._str);//拷贝内容
	}

现代写法：

	//拷贝构造的现代写法
	String(const String& str)
		:_str(nullptr)
		, _size(0)
		, _capacity(0)
		{
   
		String tem(str._str);//调用构造函数，创建一个临时变量
		Swap(tem);
		}

交换函数

void Swap(String& str){
   
		swap(_str, str._str);
		swap(_size, str._size);
		swap(_capacity, str._capacity);
		}

赋值运算符重载

传统写法：

	String& operator=(const String& str){
   
		if (this != &str){
   //判断是否为自己给自己赋值
			char* temp = new char[str._capacity + 1];//开空间

			strcpy(temp, str._str);//拷贝内容

			delete[] _str;//释放原有空间
			_str = temp;
			_size = str._size;
			_capacity = str._capacity;
		}
		return *this;
	}

现代写法：

	//赋值运算符的现代写法
	//传值->发生值拷贝->调用拷贝构造->开空间->内容拷贝
	String& operator = (String str){
   
		Swap(str);//交换临时变量（str的拷贝）与*this;
		return *this;
	}

拷贝构造与赋值运算符重载函数的现代写法都是基于Swap（）函数来写的；

插入函数

尾插