目录

一.    不考虑增删查改，只考虑深浅拷贝的string

string.h

 test.cpp

拷贝构造函数（深拷贝）：

=赋值函数

（1）考虑自己赋给自己的情况

（2）考虑new开辟失败的情况（继续优化）

二.考虑完善的增删查改和使用的string

string.h

构造函数：

一.    不考虑增删查改，只考虑深浅拷贝的string

先实现一个简单的string，只考虑资源管理深浅拷贝问题
暂且不考虑增删查改

string.h

#include 

//class String
//class mystring

namespace bit
{
	// 先实现一个简单的string，只考虑资源管理深浅拷贝问题
	// 暂且不考虑增删查改
	class string
	{
	public:
		string(const char* str)//构造函数，带const的str不能直接给非const的_str，应用参数列表
			:_str(new char[strlen(str)+1])    //多开一个为
		{
			strcpy(_str, str);
		}

		// s2(s1)
		string(const string& s)    //拷贝构造函数
			:_str(new char[strlen(s._str)+1])    //深拷贝
		{
			strcpy(_str, s._str);
		}

		string& operator=(const string& s)
		{
			if (this != &s)    //防止自己赋给自己的情况，s1=s1
			{
//				delete[] _str;
//				_str = new char[strlen(s._str) + 1];
//				strcpy(_str, s._str);
				char* tmp = new char[strlen(s._str) + 1];
				strcpy(tmp, s._str);
				delete[] _str;
				_str = tmp;
			}

			return *this;
		}
    
		~string()        //析构函数
		{
			if (_str)
			{
				delete[] _str;
			}
		}

		const char* c_str() const    //转c格式，方便打印
		{
			return _str;
		}

		char& operator[](size_t pos)    //[]函数
		{
			assert(pos < strlen(_str));

			return _str[pos];
		}

		size_t size()        //得字符串大小
		{
			return strlen(_str);
		}

	private:
		char* _str;
	};
}

 test.cpp

#include 
#include 
using namespace std;

#include "string.h"

void test_string1()
{
	bit::string s1("hello world");    //测试构造函数
	cout << s1.c_str() << endl;       //测试c_str()

	s1[0] = 'x';                //直接给[]函数带引用的返回值赋值了，s1.operator[](0)='x';
	cout << s1.c_str() << endl;

	for (size_t i = 0; i < s1.size(); ++i)
	{
		cout << s1[i] << " ";    //测试[]
	}
	cout << endl;
}

void test_string2()    
{
	bit::string s1("hello world");
	bit::string s2(s1);            //测试深拷贝的拷贝构造函数
	cout << s1.c_str() << endl;
	cout << s2.c_str() << endl;

	s1[0] = 'x';                   //修改s1，因为是深拷贝，s2不改变

	cout << s1.c_str() << endl;
	cout << s2.c_str() << endl;
}

拷贝构造函数（深拷贝）：

有指向资源，浅拷贝s1和s2指向同一空间，会导致这块空间被析构两次；所以务必用深拷贝

//深拷贝：// s2(s1)
		string(const string& s)    //拷贝构造函数
			:_str(new char[strlen(s._str)+1])    
		{
			strcpy(_str, s._str);
		}
//浅拷贝：1.
         string(const string& s)    //拷贝构造函数
			:_str(s._str)    
		{
			strcpy(_str, s._str);
		}   
        //2.不写，编译器自动生成的

=赋值函数

（1）考虑自己赋给自己的情况

当s1=s3正常使用没问题，先把s1的存字符串的空间清除： delete[] _str; ，新开一块跟s3一样大小的空间，再把s3的内容拷贝给s1。

若s1=s1就有问题，先把s1的存字符串的空间清除： delete[] _str; ，新开一块跟s1一样大小的空间，再把s1的内容拷贝给s1自己时，因为s1已经清除，所以全是随机值。（还是有小毛病的）

（2）考虑new开辟失败的情况（继续优化）

如果下面的new开辟失败了，如果像注释的第一种写法，先把s1的存字符串的空间清除： delete[] _str; 再新开一块跟s1一样大小的空间，再把s1的内容拷贝给s1自己，会有一个问题：new开辟空间如果失败后会抛异常，直接跳出这个函数，开辟失败就算了，主要是已经把s1空间给释放了，之前的数据也没了。所以应该先在tmp开空间，并把s2的数据拷贝进去，再释放s1，最后把tmp赋给s1。

string& operator=(const string& s)
		{
			if (this != &s)    //防止自己赋给自己的情况，s1=s1
			{
//	1.			delete[] _str;    
//				_str = new char[strlen(s._str) + 1];
//				strcpy(_str, s._str);
				char* tmp = new char[strlen(s._str) + 1];
				strcpy(tmp, s._str);
				delete[] _str;
				_str = tmp;
			}

			return *this;
		}

二.考虑完善的增删查改和使用的string

string.h

namespace bit
{
	// string需要考虑完善的增删查改和使用的string
	class string
	{
	public:
		

		// 全缺省
		// ""  ""  ''
		string(const char* str = "")    //缺省值""相当于给了一个，""是两个，''是一个ASCII为0的字符
			: _size(strlen(str))    
			, _capacity(_size)
		{
 //成员变量 在类中声明次序就是他在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。_str放第一个了，所以第一个初始化，因为里面用到了capacity，所以把它放在函数体内，让它最后一个初始化
			_str = new char[_capacity + 1];  //_capacity是有效字符大小，不包括，所以开空间时要开 _capacity + 1 大小的空间，这样才有位置
			strcpy(_str, str);
		}

		// s2(s1)
		string(const string& s)
			:_size(strlen(s._str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, s._str);
		}

		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;
		}

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

		const char* c_str() const
		{
			return _str;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);

			return _str[pos];
		}

		size_t size() const
		{
			return _size;
		}

		size_t capacity() const
		{
			return _capacity;
		}

		string& operator+=(const char* str)
		{
			append(str);
			return *this;
		}
		
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		void reserve(size_t n)    //总大小扩容到n+1
		{
			if (n > _capacity)    //reserve 没有缩容的功能
			{
				char* tmp = new char[n + 1];    //开一个大小为n+1的tmp
				strcpy(tmp, _str);            //把原数据拷贝到tmp中
				delete[] _str;                //释放原空间
				_str = tmp;                   //使原空间指针指向tmp

				_capacity = n;                //有效字符容量_capacity置为n
			}
		}

		// 扩空间+初始化
		// 删除部分数据，保留前n个
		void resize(size_t n, char ch = '')
		{
			if (n < _size)
			{
				_size = n;
				_str[_size] = '';
			}
			else
			{
				if (n > _capacity)
				{
					reserve(n);
				}

				for (size_t i = _size; i < n; ++i)
				{
					_str[i] = ch;
				}
				_size = n;
				_str[_size] = '';
			}	
		}
	
		void push_back(char ch)    
		{
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity*2);
				//reserve(_capacity*2); 如果没有数据时_capacity=0直接 push_back 就错了，应该改成上面的写法
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '';
		}

		void append(const char* str)
		{
			size_t len = _size + strlen(str);
			if (len > _capacity)
			{
				reserve(len);
			}

			strcpy(_str + _size, str);
			_size = len;
		}

		void insert(size_t pos, const char* str);
		void earse(size_t pos, size_t len);
		//void find;

	private:
		char* _str;
		size_t _size;     // 有效字符个数
		size_t _capacity; // 实际存储有效字符的空间
	};

	bool operator<(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str()) < 0;
	}

	bool operator==(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str()) == 0;
	}

	bool operator<=(const string& s1, const string& s2)
	{
		return s1 < s2 || s1 == s2;
	}

	bool operator>(const string& s1, const string& s2)
	{
		return !(s1 <= s2);
	}

	bool operator>=(const string& s1, const string& s2)
	{
		return !(s1 < s2);
	}

	bool operator!=(const string& s1, const string& s2)
	{
		return !(s1 == s2);
	}
}

构造函数：

前面注释部分是无参的默认构造函数，没必要写，我们希望写一个给全缺省的默认构造函数

""  ""  '' 三个的区别：""相当于一个，""是两个，''是一个ASCII为0的字符

标准用法 string(const char* str = "") ：这里给""，str这个指针指向一个空间，这个空间大小是1，只有一个，没有有效字符 : _size(strlen(str))变成了_size(0)  , _capacity(_size)变成了_capacity(0)，_str = new char[_capacity + 1]; ——>_str = new char[1]; 这样是正确的。

如果给""，也可以，但是没必要

如果给''，错误：相当于string(const char* str = 0)，类型都不同

如果给nullptr，错误：跟给''一样，相当于string(const char* str = 0)，类型都不同

       

		// 全缺省的默认构造函数
		// ""  ""  ''
		string(const char* str = "")    //缺省值""相当于给了一个，""是两个，''是一个ASCII为0的字符
			: _size(strlen(str))    
			, _capacity(_size)
		{
 //成员变量 在类中声明次序就是他在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。_str放第一个了，所以第一个初始化，因为里面用到了capacity，所以把它放在函数体内，让它最后一个初始化
			_str = new char[_capacity + 1];  //_capacity是有效字符大小，不包括，所以开空间时要开 _capacity + 1 大小的空间，这样才有位置
			strcpy(_str, str);
		}