今天你学C++了吗？——string（下）

class my_string//与库里面的进行区分
{
private:
	char* _str;//字符指针
	size_t _size;//统计长度
	size_t _capacity;//统计最大容量
};

class my_string//与库里面的进行区分
{
private:
	char* _str;//字符指针
	size_t _size;//统计长度
	size_t _capacity;//统计最大容量
	const static size_t _npos;//静态常量，用于表示一个无效的位置或未找到的位置
public:
	//成员函数

};

namespace Xiaodu
{
	class my_string//与库里面的进行区分
	{
	private:
		char* _str;//字符指针
		size_t _size;//统计长度
		size_t _capacity;//统计最大容量
		const static size_t _npos;//静态常量，用于表示一个无效的位置或未找到的位置
	public:
		//成员函数

	};
}

namespace Xiaodu
{
	const  size_t my_string::_npos = -1;
	//构造
	my_string::my_string(const char* str)//常量字符串
		:_size(strlen(str))//使用strlen求有效长度来初始化
	{
		//使用已经初始化的_size来初始化剩下的
		_capacity = _size;
		_str = new char[_size + 1];
		strcpy(_str, str);
	}
}

//默认构造
my_string::my_string()
{
	_str = new char[1];
	_str[0] = '\0';//一个字符保存'\0'
	_size = 0;
	_capacity = 0;
}

my_string::my_string(size_t n, char ch)
	:_size(n),_str(new char[n+1]),_capacity(n)
{
	for (int i = 0; i < n; i++)
	{
		_str[i] = ch;
	}
	_str[_size] = '\0';//结束标志\0
}

//析构
my_string::~my_string()
{
	delete _str;//new,delete匹配使用
	_str = nullptr;
	_size = 0;
	_capacity = 0;
}

ostream& operator<<(ostream& out, my_string& s)
{
	out << "_str:" << s._str << endl;
	out << "_size:" << s._size << endl;
	out << "_capacity:" << s._capacity << endl;
	return out;
}

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

//现代写法
my_string::my_string(const my_string& s)
{
	my_string tmp(s._str);//让构造帮我们写
	swap(_str, tmp._str);
	swap(_size, tmp._size);
	swap(_capacity, tmp._capacity);
}

//赋值运算符重载
//my_string::operator=——这样指定类域
//s4=s3
my_string& my_string::operator=(my_string& s)
{
	//判断是不是自己给自己赋值
	if (this != &s)
	{
		delete _str;//释放原来的，重新开辟空间
		_str = new char[s._capacity + 1];
		strcpy(_str, s._str);
		_size = s._size;
		_capacity = s._capacity;
	}
	return *this;
}

void my_string::reserve(size_t n)
{
	if (n > _capacity)//修改容量比原来的大就进行扩容
	{
		char* tmp = new char[n + 1];
		//创建一个中间指针变量修改容量
		strcpy(tmp, _str);
		delete _str;
		_str = tmp;
		_capacity = n;
	}
}

void my_string::push_back(char ch)
{
	//判断容量是否足够
	if (_capacity == _size)//容量不够进行扩容
	{
		//这里就可以使用reserve进行代码复用
		reserve(_capacity == 0 ? 4 : _capacity * 2);
	}
	_str[_size++]=ch;//插入字符后长度增加
	_str[_size] = '\0';
}

void my_string::append(const char* s)
{
	//求出插入字符串长度
	size_t l = strlen(s);
	//容量不够进行扩容
	if (_size + l > _capacity)
	{
		//默认两倍扩容，还是不够就按需扩容
		size_t newcapacity = _capacity * 2;
		if (_size + l > newcapacity)
		{
			newcapacity = _size + l;
		}
		//1.自己重新写
		char* tmp = new char[newcapacity + 1];//容量记得+1，需要一个字符串结束标志
		strcpy(tmp, _str);
		delete _str;
		_str = tmp;
		_capacity = _size + l;
		//2.代码复用
		//reserve(newcapacity);
	}
	//拷贝剩下的
	strcpy(_str + _size, s);
	//_size增加
	_size += l;
}

//+=一个字符
my_string& my_string::operator+=(char c)
{
	push_back(c);
	return *this;
}
//返回引用，减少拷贝
//+=一个字符串
my_string& my_string::operator+=(const char* c)
{
	append(c);
	return *this;
}

//insert字符
void my_string::insert(size_t pos, size_t n, char c)
{
	//判断插入位置和插入个数是否合法
	assert(pos < _size);
	assert(n > 0);
	//判断容量是否足够
	//不够进行扩容
	if (_size + n > _capacity)
	{
		//默认两倍扩容，还是不够就按需扩容
		size_t newcapacity = _capacity * 2;
		if (_size + n > newcapacity)
		{
			newcapacity = _size + n;
		}
		//代码复用
		reserve(newcapacity);
	}
	//移动后面的字符
	size_t end = _size + n - 1;
	//从后面开始移动，避免覆盖
	while (end > pos + n - 1)
	{
		_str[end] = _str[end - n];
		end--;
	}
	//插入字符
	for (size_t i = pos; i < pos + n; i++)
	{
		_str[i] = c;
	}
	_size += n;
	//字符串末尾置为'\0'
	_str[_size] = '\0';
}

void my_string::insert(size_t pos, const char* s)
{
	//方法一：重新写
	//判断插入位置和插入个数是否合法
	size_t n = strlen(s);
	assert(pos < _size);
	assert(n);
	//判断容量是否足够
	//不够进行扩容
	if (_size + n > _capacity)
	{
		//默认两倍扩容，还是不够就按需扩容
		size_t newcapacity = _capacity * 2;
		if (_size + n > newcapacity)
		{
			newcapacity = _size + n;
		}
		//代码复用
		reserve(newcapacity);
	}
	//移动后面的字符
	size_t end = _size + n - 1;
	//从后面开始移动，避免覆盖
	while (end > pos + n - 1)
	{
		_str[end] = _str[end - n];
		end--;
	}
	//插入字符串里面的字符
	for (size_t i = pos; i < pos + n; i++)
	{
		_str[i] = s[i - pos];
	}
	_size += n;
	//字符串末尾置为'\0'
	_str[_size] = '\0';
}

void my_string::insert(size_t pos, const char* s)
{
	//方法二：代码复用
	size_t n = strlen(s);
	//先占位置，再重新赋值
	insert(pos, n, 'x');
	for (size_t i = 0; i < n; i++)
	{
		_str[pos + i] = s[i];
	}
}

//erase
void my_string::erase(size_t pos, size_t n)
{
	//判断删除位置
	if (pos + n >= _size)
		//也就是后面的全部删除
	{
		_str[pos] = '\0';
		_size -= n;
	}
	else
		//删除直接进行覆盖就好了
	{
		//把后面的字符向前面移动
		size_t begin = pos + n;
		while (begin < _size)
		{
			_str[begin - n] = _str[begin];
			begin++;
		}
		_size -= n;
		_str[_size] = '\0';
	}
}

//find字符
size_t my_string::find(char c,size_t pos)
	//默认从开头开始找
{
	//遍历查找
	size_t n = strlen(_str);
	for (size_t i = pos; i < n; i++)
	{
		if (_str[i] == c)
		{
			//找到了返回下标
			return i;
		}
	}
	//找不到返回_npos
	return _npos;
}

//find字符串
size_t my_string::find(const char* s, size_t pos)
{
	const char* p = strstr(_str + pos, s);//从指定位置开始查找子字符串
	if (p == nullptr)//没有找到，返回_npos
	{
		return _npos;
	}
	else//找到了，返回下标索引
	{
		return p - _str;
	}
}

//substr
my_string my_string::substr(size_t pos, size_t len)
{
	size_t n = strlen(_str);
	assert(pos >= 0);
	assert(pos < n);//判断拷贝位置有效
	my_string tmp;//调用默认构造
	tmp._str = new char[len + 1];
	//进行拷贝
	for (size_t i = pos; i < pos + len; i++)
	{
		tmp._str[i - pos] = _str[i];
	}
	tmp._str[len] = '\0';
	tmp._size = tmp._capacity = len;//修改容量和长度
	return tmp;
}

//==
//s1==s2
bool my_string::operator==(const my_string& s)const
{
	return strcmp(_str, s._str) == 0;//判断返回值是否等于0
}
//!=
bool my_string::operator!=(const my_string& s)const
{
	return !(*this == s);//代码复用
}
//<
bool my_string::operator<(const my_string& s)const
{
	return strcmp(_str, s._str) < 0;
}
//<=
bool my_string::operator<=(const my_string& s)const
{
	return (*this == s) || (*this < s);
}
//>
bool my_string::operator>(const my_string& s)const
{
	return !(*this <= s);
}
//>=
bool my_string::operator>=(const my_string& s)const
{
	return !(*this < s);
}

ostream& operator<<(ostream& out, my_string& s)
{
	cout << s._str;
	return out;
}

//>>运算符重载
istream& operator>>(istream& in, my_string& s)
{
	char ch;
	in >> ch;
	while (ch != ' ' && ch != '\n')
	{
		s += ch;
		in >> ch;
	}
	return in;
}

//>>运算符重载
istream& operator>>(istream& in, my_string& s)
{
	//清理原来的字符串
	s.clear();
	char ch = in.get();//调用get
	while (ch != ' ' && ch != '\n')
	{
		s += ch;
		ch = in.get();
	}
	return in;
}

//>>运算符重载（优化版）
istream& operator>>(istream& in, my_string& s)
{
	//清理原来的字符串
	s.clear();
	const size_t N = 1024;//可以自己指定大小
    char arr[N];//使用一个临时数组（出了当前作用域就销毁）来存储写入的字符数据
	int i = 0;
	char ch = in.get();//调用get
	while (ch != ' ' && ch != '\n')
	{
		arr[i++] = ch;
		if (i == N - 1)
		{
			arr[i] = '\0';
			s += arr;//字符串很长的情况下，调用+=可以按需扩容
			i = 0;//i重新开始保存数据
		}
		ch = in.get();
	}
	if (i > 0)//arr里面还有字符数据
	{
		arr[i] = '\0';//末尾置为'\0'再进行插入
		s += arr;
	}
	return in;
}

//getline
istream& getline(istream& in, my_string& s, char end)
{
	//清理原来的字符串
	s.clear();
	const size_t N = 1024;
	char arr[N];//使用一个临时数组（出了当前作用域就销毁）来存储写入的字符数据
	int i = 0;
	char ch = in.get();//调用get
	while (ch != end)
	{
		arr[i++] = ch;
		if (i == N - 1)
		{
			arr[i] = '\0';
			s += arr;//字符串很长的情况下，调用+=可以按需扩容
			i = 0;//i重新开始保存数据
		}
		ch = in.get();
	}
	if (i > 0)//arr里面还有字符数据
	{
		arr[i] = '\0';//末尾置为'\0'再进行插入
		s += arr;
	}
	return in;
}