string类

string类

string是表示字符串的字符串类

string类对象的常见构造

void TestString()
{
string s1; // 构造空的string类对象s1
string s2("hello bit"); // 用C格式字符串构造string类对象s2
string s3(10, 'a'); // 用10个字符'a'构造string类对象s3
string s4(s2); // 拷贝构造s4
string s5(s3, 5); // 用s3中前5个字符构造string对象s5
}

string类对象的常见操作

函数名称	功能说明
size_t size() const	返回字符串有效字符长度
size_t capacity ( ) const	返回空间总大小
void clear()	清空有效字符
void resize ( size_t n, char c )	将有效字符的个数该成n个，多出的空间用字符c填充
void resize ( size_t n )	将有效字符的个数改成n个，多出的空间用0填充
void push_back(char c)	在字符串后尾插字符c
string& append (const char* s)	在字符串后追加一个字符串
string& operator+=(const string& str)	在字符串后追加字符串str
size_t find (char c, size_t pos = 0)const	从字符串pos位置开始往后找字符c，返回该字符在字符串中的位置

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

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

string类的模拟实现

namespace bit
{
	class string
	{
	public:
		typedef char* Iterator;
		public:
		//构造
		string(const char* str = "")
		{
			if (str == nullptr)
			{
				assert(str);
				return;
			}
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}
		//拷贝构造
		string(const string& s)
			:_str(new char[s._capacity + 1])
			, _size(s._size)
			, _capacity(s._capacity)
			{
			strcpy(_str,s._str);
		}
		//重载
		string& operator=(const string& s)
		{
			if (this != &s)
			{
				char* pStr = new char[s._capacity + 1];
				strcpy(pStr, s._str);
				delete[] _str;
				_str = pStr;
				_size = s._size;
				_capacity = s._capacity;
			}
				return *this;
		}
		//析构
		~string()
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
			}
		}
		//扩容
		void Reserve(size_t NewCapacity)
		{
			if (NewCapacity > _capacity)
			{
				char* str = new char(NewCapacity);
				strcpy(str, _str);
				delete[] _str;
				_str = str;
				_capacity = NewCapacity;
			}
		}
		//尾插
		void PushBack(char c)
		{
			if(_size == _capacity)
			{
				Reserve(_capacity * 2);
			}
			_str[_size++] = c;
			_str[_size] = '\0';
		}
		
		private:
		friend ostream& operator <<(ostream& _this, const bit::string& s);
		
		private:
		char* _str;
		size_t _size;
		size_t _capacity;
	}；
}

ostream& bit :: operator << (ostream& _this, const bit::string& s)
{
	cout << s._str;
	return _this;
}