string 类的部分实现

版权声明： https://blog.csdn.net/qq_41880190/article/details/84937979

string 类的部分实现

void pushback(char c);尾插

void append(size_t n, char c);尾插 n 个字符 c

string& operator+=(const char* str);追加字符串 str

void resize(size_t newsize, char c = char());修改有效字符个数

void reserve(size_t newcapacity);为字符串预留空间

size_t find(char c, size_t pos = 0) const;返回字符 c 在字符串第一次出现的位置

size_t find(const char* str, size_t pos = 0) const;返回字串在字符串第一次出现的位置

string substr(size_t pos, size_t n);截取从 pos 位置开始的 n 个字符

string& insert(size_t pos, char c); string& insert(size_t pos, const char* str);在 pos 位置插入字符 c 或者字符串 str ，并返回该字符串的位置

string& erase(size_t pos, size_t len);删除 pos 位置上的元素，并返回该元素的下一个位置

string& append(const char* str);在字符串后面追加 str

string& operator+=(const string& str);在字符串后面追加 str

namespace fun
{
	class String
	{
	public:
		String(const char* str = "")
		{
			if (nullptr == str)
			{
				assert(false);
				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;
			}
		}
	public:
		void pushback(char c)
		{
			if (_size == _capacity)
				reserve(_capacity * 2);
			_str[_size++] = c;
			_str[_size] = '\0';
		}
		void append(size_t n, char c)
		{
			for (size_t i = 0; i < n; ++i)
			{
				pushback(c);
			}
		}
		void reserve(size_t newcapacity)
		{
			//如果新容量大于旧容量，则开辟新空间
			if (newcapacity > _capacity)
			{
				char* str = new char[newcapacity + 1];
				strcpy(str, _str);//把旧空间内容拷贝至新空间
				//释放旧空间，然后使用新空间
				delete[] _str;
				_str = str;
				_capacity = newcapacity;
			}
		}
		String& operator+=(char c)
		{
			pushback(c);
			return *this;
		}
		String& operator+=(const char* str);//追加字符串
		void resize(size_t newsize, char c = char())
		{
			if (newsize > _size)
			{
				//如果 newsize 大于底层空间大小，则需要开辟空间
				if (newsize > _capacity)
				{
					reserve(newsize);
				}
				memset(_str + _size, c, newsize - _size);
			}
			_size = newsize;
			_str[newsize] = '\0';
		}
	private:
		char* _str;
		size_t _capacity;
		size_t _size;
	};
}