【C++】模拟实现string类

链接: 认识使用string类

前文已经讲解过如何使用string类，下面主要讲解如何模拟实现常用的string类函数，以及对深拷贝和浅拷贝的讲解。

模拟实现string类

namespace imitate
{
   
	class string
	{
   };
}

首先创建一个命名空间域，这个域被用来模拟string类。

	class string
	{
   
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};

类中的私有成员变量同顺序表一样，包括字符数组、无符号整型_size和_capcity。

	public:
		string(const char* str = "")
		{
   
			_size = strlen(str);
			_capacity = strlen(str);
			_str = new char[_capacity + 1];
			memcpy(_str, str, _size + 1);
		}

类中模拟实现默认构造函数，内置成员变量类型未写在初始化列表是因为_str的初始化需要动态开辟。

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

模拟实现默认析构函数。

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

模拟实现返回c字符串函数，方便后续验证。

		size_t size() const
		{
   
			return _size;
		}

模拟实现size函数，可以获取字符串的长度

		char& operator[](size_t pos)
		{
   
			assert(pos <= _size);
			return _str[pos];
		}

		const char& operator[](size_t pos) const
		{
   
			assert(pos <= _size);
			return _str[pos];
		}

模拟实现operator[ ]函数，可以用于遍历字符串；前者是用于可以修改的字符串；后者是用于不可修改的字符串。

		typedef char* iterator;
		typedef const char* const_iterator;

		iterator begin()
		{
   
			return _str;
		}
		iterator end()
		{
   
			return _str + _size;
		}
		const_iterator begin() const 
		{
   
			return _str;
		}
		const_iterator end() const
		{
   
			return _str + _size;
		}

模拟实现迭代器，可以用于遍历或者范围for的使用。

		void reserve(size_t n = 0)
		{
   
			if (n > _capacity)
			{
   
				char* tmp = new char[n + 1];
				memcpy(tmp, _str, _size);
				delete[] _str;
				_capacity = n;
				_str = tmp;
			}
		}

模拟实现reserve()函数，用于请求字符串容量，new char[n+1]是为了后续扩容时，保证可以将’\0’录入

		void push_back(char c)
		{
   
			if (_capacity == _size)
			{
   
				//二倍扩容:判断_capacity是否为空
				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}
			_str[_size] = c;
			++_size;
			_str[_size] = '\0';
		}

模拟实现push_back()函数，后增一个字符。

		string& append(const char* s)
		{
   
			size_t len = strlen(s);
			if (_size + len > _capacity)
			{
   
				reserve(_size + len);
			}
			memcpy(_str + _size, s, _size + len + 1);
			_size += len;
			return *this;
		}

模拟实现append()函数，后增字符串。

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

模拟实现operator+=()函数，方便字符串的后增。

	class string
	{
   
	public:
		const static size_t npos;
	};
	const size_t string::npos = -1;

模拟一个静态成员变量，静态成员变量的初始化需要在类外面。

		void insert(size_t pos, size_t n, char c)
		{
   
			assert(pos <= _size);
			if (_size + n > _capacity)
			{
   
				reserve(_size + n);
			}
			//挪动数据
			size_t end = _size;
			//end不等于npos是为了防止原字符串为空
			while (end >= pos && end != npos)
			{
   
				_str[end + n] = _str[end];
				--end;
			}
			//添加数据
			for (size_t i = pos; i < n + pos; ++i)
			{
   
				_str[i] = c;
			}
			_size += n;
		}

		void insert(size_t pos, const char* str)
		{
   
			assert(pos <= _size);
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
   
				reserve(_size + len);
			}
			//挪动数据
			size_t end = _size;
			//end不等于npos是为了防止原字符串为空
			while (end >= pos && end != npos)
			{
   
				_str[end + len] = _str[end