STL中string类基本概念及模拟实现_可以把std string作为基类吗

3.容量操作

resize(size_t n, char ch)
resize(size_t n)
reserve(size_t n):

注意:元素增多时可能会扩容、将元素个数减少时，容量不改变
扩容
1.n > old扩容---->开辟新空间拷贝元素释放旧空间
2.n < old缩小
n > 15:不会将容量缩小
n <= 15:将空间释放掉，直接使用内部固定大小的数组
sizeof(string):28字节
char* size_t size_t + 16个字符的数组

clear() //清空

4.元素访问操作
operator[+ at(index)
5.修改modify–修改string对象管理字符串的结构

6.特殊操作

c\_str( find(char ch, size_t pos = 0) 
rfind(char ch, size_t pos = npos);

string:npos是string内部维护的一个静态成员变量
静态常量 size_t npos = -1;
size_t 的最大值
npos是一个静态成员常量值，对于size_t类型的元素具有最大可能值。
该值在string的成员函数中用作len（或sublen）参数的值时，表示“直到字符串的结尾”。 作为返回值，它通常用于表示没有匹配项。 此常量定义为-1值，因为size_t是无符号整数类型，因此它是此类型的最大可能表示值。

substr(size_t pos = o, size_t n = npos)

3. 浅拷贝与深拷贝

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

class string
{
public:
 string(const char\* str = "")
 {
 // 构造string类对象时，如果传递nullptr指针，认为程序非法，此处断言下
 if(nullptr == str)
 {
 assert(false);
 return;
 }
 
 _str = new char[strlen(str) + 1];
 strcpy(_str, str);
 }
 
 ~string()
 {
 if(_str)
 {
 delete[] _str;
 _str = nullptr;
 }
 }
private:
 char\* _str;
};
void Teststring()
{
 string s1("hello bit!!!");
 string s2(s1);
}

深拷贝∶给每个对象独立分配资源，保证多个对象之间不会因共享资源而造成多次释放造成程序崩溃问题

4.模拟实现string类

模拟实现string，传统版

class String
{
public:
	//构造
	String(const char \*str = "")
	{
		if (nullptr == str)
		{
			str = "";
		}
		//str是一个合法的字符串
		_str = new  char[strlen(str) + 1];
		strcpy(_str, str);
	}
	//拷贝构造，按照深拷贝的方式实现
	String(const String& s)
		:\_str(new char[strlen(s._str) + 1])
	{
		//String tmp(s);//无限递归
		strcpy(_str, s._str);
	}
	//赋值运算符重载
	String& operator = (const String& s)
	{
		if (this != &s)
		{
			//1.申请新空间
			char \*tmp = new char[strlen(s._str) + 1];
			//2.拷贝字符串
			strcpy(tmp, s._str);
			//3.释放旧空间
			delete[]_str;
			//4.使用新空间
			_str = tmp;
		}
		return \*this;		
	}
	//析构
	~String()
	{
		if (_str)
		{
			delete[]_str;
			_str = nullptr;
		}
	}
private:
	char\* _str;
};
void TestString1()
{
	String s1("hello");
	String s2(s1);
}
void TestString2()
{
	String s1("hello");
	String s2("world");
	s1 = s2;
}
int main()
{
	//TestString1();
	TestString2();
	return 0;
}

模拟实现string,深拷贝现代版

class String
{
public:
	//构造
	String(const char \*str = "")
	{
		if (nullptr == str)
		{
			str = "";
		}
		//str是一个合法的字符串
		_str = new  char[strlen(str) + 1];
		strcpy(_str, str);
	}
	//拷贝构造，按照深拷贝的方式实现
	String(const String& s)
		:\_str(nullptr)
	{
		//String tmp(s); //无限递归
		String tmp(s._str);
		swap(_str, tmp._str);
	}

	//赋值运算符重载
	String& operator = (String s)
	{
		swap(_str, s._str);