C++中写一个简单的String类

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/ZhangaZhaoLong/article/details/88964415

1. #define _CRT_SECURE_NO_WARNINGS
   #include
   #include <assert.h>
   using namespace std;

   class String
   {
   public:
   	typedef char* iterator;
   	typedef const char* const_iterator;
   
   	String(const char* str = "")
   	{
   		assert(str != nullptr);
   
   		_size = strlen(str);
   		_str = new char[_size + 1];
   		strcpy(_str, str);
   		_capacity = _size;
   	}
   
   	String(const String& str)
   		:_str(nullptr)
   		,_size(0)
   		,_capacity(0)
   	{
   		String tmp(str._str);    //通过交换来进行数据的复制
   		Swap(tmp);
   	}
   
   	~String()
   	{
   		if (_str)
   		{
   			delete[] _str;
   			_str = nullptr;
   			_size = 0;
   			_capacity = 0;
   		}
   	}
   
   	void Swap(String& str)
   	{
   		swap(str._str, _str);
   		swap(str._size, _size);
   		swap(str._capacity, _capacity);
   	}
   
   	String& operator = (String str)   //this指针现在指向，你所要访问的那个类
   	{
   		Swap(str);                    //str里的内容和this指向的类里的数据进行交换
   		return *this;
   	}
   
   	char& operator [] (size_t pos)
   	{
   		assert(pos < _size);
   		return _str[pos];
   	}
   
   	const char& operator [] (size_t pos)const
   	{
   		assert(pos < _size);
   		return _str[pos];
   	}
   
   	iterator begin()
   	{
   		return _str;
   	}
   
   	iterator end()
   	{
   		return _str + _size;
   	}
   
   	const_iterator begin()const
   	{
   		return _str;
   	}
   
   	const_iterator end()const
   	{
   		return _str + _size;
   	}
   
   	char* c_str()
   	{
   		return _str;
   	}
   
   	void Reserve(size_t n)
   	{
   		if (n > _capacity)
   		{
   			char* tmp = new char[n + 1];
   			strcpy(tmp, _str);
   			delete[] _str;
   			_str = tmp;
   			_capacity = n;
   		}
   	}
   
   	void Resize(size_t n, char c = '\0')
   	{
   		if (n > _capacity)
   		{
   			Reserve(n);
   		}
   
   		if (n > _size)
   		{
   			memset(_str + _size, c, n - _size);
   		}
   
   		_size = n;
   		_str[_size] = '\0';
   	}
   
   	void pushBack(char c)
   	{
   		if (_size == _capacity)
   		{
   			size_t newC = _capacity == 0 ? 15 : 2 * _capacity;
   			Reserve(newC);
   		}
   
   		_str[_size++] = c;
   		_str[_size] = '\0';
   	}
   
   	void popBack()
   	{
   		if (_size > 0)
   		{
   			_str[--_size] = '\0';
   		}
   	}
   
   	void Erase(size_t pos, size_t len)
   	{
   		assert(pos < _size);
   
   		if (pos + len >= _size)
   		{
   			_size = pos;
   			_str[_size] = '\0';
   		}
   		else
   		{
   			for (size_t i = pos + len; i <= _size; i++)
   			{
   				_str[pos++] = _str[i];
   			}
   			_size = pos - 1;
   		}
   	}
   
   	void Append(char* str)
   	{
   		assert(str);
   
   		size_t len = strlen(str);
   		if (_size + len >= _capacity)
   		{
   			Reserve(_size + len);
   		}
   
   		/*for (size_t i = 0; i < len; i++)
   		{
   			_str[_size + i] = str[i];
   		}*/
   		strcpy(_str + _size, str);
   
   		_size += len;
   	}
   
   private:
   	char* _str;
   	size_t _size;
   	size_t _capacity;
   };
   
   void PrintStringIterator(const String& str)
   {
   	String::const_iterator sit = str.begin();
   	while (sit != str.end())
   	{
   		cout << *sit++;
   	}
   	cout << endl;
   }
   
   int main()
   {
   	String s = "2343168753";
   	/*String s2(s);
   	String s3;
   	s3 = s2;*/
   	s.Erase(1, 3);
   	PrintStringIterator(s);
   
   	system("pause");
   	return 0;
   }