C++——string模拟实现

没有const迭代器

#pragma once
#include<iostream>
#include<assert.h>
using namespace std;
namespace my
{
	class string
	{

		friend ostream& operator<<(ostream& _cout, const my::string& s);//友元声明,参数位置问题。类成员函数默认第一个参数位置为this指针。比如正常用法为：cout<<类对象，<<重载为类成员后就只能：类对象<<cout。不符合我们的使用习惯。所以定义在类外。使用友元可以访问私有成员。

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

	public:

		typedef char* iterator;

		string(const char* str = "")
		//缺省值是否可以是str='\0'或nullptr，不可以。1.指针是不能存储字符的，取得是asc码。'\0'的asc码是0，等于给指针赋null。2.strlen函数要求不能传空指针，strlen默认传过来的是有效字符串，直到找到\0才停止。
		//【区分'\0'和"\0"和 ""】   '\0'是char。"\0"是一个字符串，里面有两个\0。  "",字符串，只有一个\0 
		{
			_size = strlen(str);
			_capacity = _size;
			_str = new char[_capacity + 1];//_capacity和_size都是有效字符个数，不含\0，申请空间的时候要再+1
			strcpy(_str, str);
		}

		//string(const string& s)//拷贝构造
		//{
		//	_str = new char[s.capacity() + 1];
		//	strcpy(_str, s._str);
		//	_capacity = s._capacity;
		//	_size = s._size;
		//}

		//现代写法的拷贝构造
		//先用构造一个临时变量拷贝下来s的_str,再swap换给目标
		//string(const string& s)
		//	:_str(nullptr)
		//	,_size(0)
		//	,_capacity(0)
		//	//换完之后tmp里都是随机值，_str是野指针。tmp出作用域要调析构函数，没办法delete，会报错。
  //          //不要给tmp换随机值过去，在换之前给s的_str初始化成nullptr。         
		//{
		//	string tmp(s._str);
		//	std::swap(_str, tmp._str);
		//	std::swap(_size, tmp._size);
		//	std::swap(_capacity, tmp._capacity);
		//}

		//优化版，swap的时候不要一个一个交换类成员变量，调swap函数
		string(const string& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			string tmp(s._str);
			swap(tmp);//调用类里的swap

		//string的swap调用：s1.swap(s2)。交换指针，交换_size和_capacity的值

		//std算法库的：swap(s1,s2)。代价太大，通过类模板实现。先推演出string类型，再3次深拷贝。

		}

		string& operator=(string s)//形参只是实参的临时拷贝
		{
			swap(s);
			return *this;
		}

		~string()//释放资源
		{
			delete[] _str;
			_capacity = _size = 0;
		}



		//

		// iterator
		typedef char* iterator;

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;//迭代器end()是组后一个有效数据的下一个位置，string里就是\0的位置。
		}



		/

		// modify

		void push_back(char c)
		{
			//先判断是否需要扩容
			if (_size == _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
				reserve(newcapacity);
			}

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

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

		void append(const char* str)
		{
			size_t len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(_size + len);
			}
			strcpy(_str + _size, str);
			_size += len;
		}

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

		void clear()//只清内容，不清空间
		{
			_size = 0;
			_str[0] = '\0';
		}

		void swap(string& s)
		{
			std::swap(_str, s._str);
			std::swap(_size, s._size);
			std::swap(_capacity, s._capacity);
			//必须指定命名空间。因为一个在全局域，swap不在同一个域，先优先就近找，而就近的swap参数类型不匹配就报错了。指定去标准库找swap函数。
		}

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



		/

		// capacity

		size_t size()const
		{
			return _size;
		}

		size_t capacity()const
		{
			return _capacity;
		}

		bool empty()const
		{
			return _size == 0;
		}

		void resize(size_t n, char c = '\0')
		{
			if (n > _size)//需要扩容就扩容，然后填数据
			{
				reserve(n);//不会缩容的
				for (int i = _size; i < n; i++)
				{
					_str[i] = 'c';
				}
				_size = n;
				_str[_size] = '\0';
			}
			else
			{
				_str[n] = '\0';
				_size = n;
			}
		}

		void reserve(size_t n)
		{
			if (n > _capacity)//reserve只扩容，不缩容
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[]_str;
				_str = tmp;

				_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)
		{
			return *_str < *s._str;
		}

		bool operator<=(const string& s)
		{
			return *_str < *s._str || *_str == *s._str;
		}

		bool operator>(const string& s)
		{
			return *_str > *s._str;
		}

		bool operator>=(const string& s)
		{
			return *_str > *s._str || *_str == *s._str;
		}

		bool operator==(const string& s)
		{
			return *_str == *s._str;
		}

		bool operator!=(const string& s)
		{
			return !(*_str == *s._str);
		}


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

		size_t find(char c, size_t pos = 0) const
		{
			assert(pos < _size);
			while (pos < _size)
			{
				if (_str[pos] != c)
				{
					pos++;
				}
				else
				{
					return pos;
				}
			}
			return npos;
		}

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

		size_t find(const char* s, size_t pos = 0) const
		{
			assert(pos < _size);
			const char* ptr = strstr(_str + pos, s);
			if (ptr == nullptr)
			{
				return npos;
			}
			else
			{
				return ptr - _str;
			}
		}

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

		string& insert(size_t pos, char c)
		{
			assert(pos <= _size);
			if (_size == _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
				reserve(newcapacity);
			}

			int end = _size;
			while (end >= (int)pos)//强转是因为双目操作符两边操作数类型不一样会算数转换。int会转为size_t
			{
				_str[end + 1] = _str[end];
				end--;
			}

			//放数据加修改容量
			_str[pos] = c;
			_size++;

			return *this;
		}

		string& insert(size_t pos, const char* str)
		{
			assert(pos < _size);
			//判断需不需要扩容
			int len = strlen(str);
			if (_size + len > _capacity)
			{
				reserve(len + _size);
			}
			int end = _size;
			while (end >= (int)pos)
			{
				_str[end + len] = _str[end];
				end--;
			}

			strncpy(_str + pos, str, len);
			_size + len;
			return *this;
		}



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

		string& erase(size_t pos, size_t len=npos)
		{
			assert(pos < _size);
			if (len == npos || _size + len >= _size)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str + pos + len);
				_size -= len;
			}
			return *this;
		}

	private:

		char* _str;

		size_t _capacity;

		size_t _size;

		const static size_t npos = -1;//特例。静态成员变量不会在初始化列表初始化，不能在类里面初始化，而是去类外面初始化。这里const 的 static 是特例，且只针对整型。
	};

	istream& operator >> (istream& in, my::string s)
	{
		s.clear();//防止s里原来有数据
		char buff[128] = { '\0' };
		size_t i = 0;
		char ch = in.get();//用ch一个字符一个字符接收，存到buff里
		while (ch != ' ' && ch != '\n')//需要判断从缓冲区拿到的是否为空格（拿到空格和\n就停止，因为默认的流提取是无法提取空格的）
		{
			if (i == 127)//数组存满了，全存到s里，然后刷新
			{
				s += buff;
				i = 0;
			}
			buff[i++] = ch;
			ch = in.get();
		}
		if (i > 0)//跳出循环后buff里没存满，有一部分有效数据
		{
			buff[i] = '\0';
			s += buff;
		}
		return in;
	}

	ostream& operator<<(ostream& _cout, my::string& s)
	{
		for (auto e : s)
		{
			_cout << e;
		}

	}

}