8.string（下）

底层原理模拟实现

string构造析构等实现
using namespace std;
class string
{
public:
	string(const char* str = "")
	{
		if (nullptr == str)
		{
			assert(false);
			return;
		}
		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
	}




	string(const string &s)
		: _str(new char[strlen(s._str) + 1)
	{
		strcpy(_str, s._str);
	}


	string& operator = (const string &s)
	{
		if (this != &s)
		{
			char* pstr = new char[strlen(s._str) + 1];
			strcpy(pstr, s.str);
			delete[]_str;
			_str = pstr;
		}


		return *this;
	}




	~string()
	{
		if (_str)
		{
			delete[] _str;
			_str = nullptr;
		}
	}
private:
	char* _str;
};

namespace zy     //实现一个string
{

	class string

	{

	public:

		typedef char* iterator;//所以string的迭代器是一个char*指针

	public:

		string(const char* str = "")//不传参构造
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		string(const string& s)//传参构造
			: _str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			string tmp(s._str);
			this->swap(tmp);
		}

		string& operator=(const string &s)//赋值运算符重载
		{
			this->Swap(s);
			return *this;
		}

		~string()//析构函数
		{
			if (_str)
			{
				delete[] _str;
				_str = nullptr;
			}
		}


			//////////////////////////////////////////////////////////////

			// iterator

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}



			/////////////////////////////////////////////////////////////

			// modify

		void push_back(char c)
		{
			if (_size == _capacity)//扩容
				reserve(_capacity * 2);

			_str[_size++] = c;//尾插
			_str[_size] = '\0';
		}

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

		void append(const char* str)
		{
			if (_size == _capacity)//扩容
				reserve(_capacity * 2);
			_str[_size++] = *str;//尾插
			_str[_size] = '\0';
		}

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

		void clear()
		{
			_size = 0;
			_str[_size] = '\0';
		}

		void swap(string& s)
		{
			swap(_str, s._str);
			swap(_size, s._size);
			swap(_capacity, s._capacity);
		}

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



		/////////////////////////////////////////////////////////////

		// capacity

		size_t size()const

			size_t capacity()const

			bool empty()const

			void resize(size_t n, char c = '\0');

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* str = new char[n + 1];
				strcpy(str, _str);
				delete[]_str;
				_str = str;
				_capacity = n;
			}
		}



		/////////////////////////////////////////////////////////////

		// access

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

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



		/////////////////////////////////////////////////////////////

		//relational operators

		bool operator<(const string& s);

		bool operator<=(const string& s);

		bool operator>(const string& s);

		bool operator>=(const string& s);

		bool operator==(const string& s);

		bool operator!=(const string& s);



		// 返回c在string中第一次出现的位置

		size_t find(char c, size_t pos = 0) const;

		// 返回子串s在string中第一次出现的位置

		size_t find(const char* s, size_t pos = 0) const;

		// 在pos位置上插入字符c/字符串str，并返回该字符的位置

		string& insert(size_t pos, char c);

		string& insert(size_t pos, const char* str);



		// 删除pos位置上的元素，并返回该元素的下一个位置

		string& erase(size_t pos, size_t len);
	private:

		friend ostream& operator<<(ostream& _cout, const bit::string& s);

		friend istream& operator>>(istream& _cin, bit::string& s);


	private:

		char* _str;

		size_t _capacity;

		size_t _size;

	}

}；

oj题

第一遍这里学的有点吃力，后续会补上。