【C++】模拟实现string类

模拟实现string类

• 模拟实现string类
• 浅拷贝与深拷贝
• 写时拷贝（了解）
• 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 
  			assert(pos 
  			return _str;
  		}
  		iterator end()
  		{
  			return _str + _size;
  		}
  		const_iterator begin() const 
  		{
  			return _str;
  		}
  		const_iterator end() const
  		{
  			return _str + _size;
  		}
  
  			if (n  _capacity)
  			{
  				char* tmp = new char[n + 1];
  				memcpy(tmp, _str, _size);
  				delete[] _str;
  				_capacity = n;
  				_str = tmp;
  			}
  		}
  
  			if (_capacity == _size)
  			{
  				//二倍扩容:判断_capacity是否为空
  				reserve(_capacity == 0 ? 4 : _capacity * 2);
  			}
  			_str[_size] = c;
  			++_size;
  			_str[_size] = '\0';
  		}
  
  			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  _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  
  		void insert(size_t pos, const char* str)
  		{
  			assert(pos  _capacity)
  			{
  				reserve(_size + len);
  			}
  			//挪动数据
  			size_t end = _size;
  			//end不等于npos是为了防止原字符串为空
  			while (end >= pos && end != npos)
  			{
  				_str[end + len] = _str[end];
  				--end;
  			}
  			//添加数据
  			for (size_t i = 0; i  
  模拟实现insert()函数，用于插入n个字符或者字符串。
   
  		void erase(size_t pos, size_t len = npos)
  		{
  			assert(pos = _size || len == npos)
  			{
  				_str[pos] = '\0';
  				_size = pos;
  			}
  			else
  			{
  				size_t end = pos + len;
  				while (end 
  					_str[pos++] = _str[end++];
  				}
  				_size -= len;
  			}
  		}
  
  			assert(pos 
  				if (_str[i] == c)
  				{
  					return i;
  				}
  			}
  			return npos;
  		}
  
  			assert(pos 
  				n = _size - pos;
  			}
  			string tmp;
  			reserve(n);
  			for (int i = 0; i = pos && end != npos)
  			{
  				_str[end + len] = _str[end];
  				--end;
  			}
  			//添加数据
  			for (size_t i = 0; i