C++：_String类的增删查改

1、概念：

1. string是表示字符串的字符串类

2. 该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作。

3. string在底层实际是：basic_string模板类的别名,typedef basic_string<char,char_traits,allocator> string。

4. 不能操作多字节或者变长字符的序列。

在使用string类时，必须包含#include头文件以及using namespace std;

2、常用接口：

1、创建一个string类：

class string
{

public:




private:
	char* _str = nullptr;//string对象的首地址
	size_t _size = 0;//string对象内容的大小
	size_t _capacity = 0;//string对象容量大小

public:
	static const int npos;
};

2、构造函数

string（）构建一个类对象，空字符串

string()
    :_str(new char[1])
	,_size(0)
	,_capacity(0)
{
	_str[0] = '\0';
}

string（const char*s）用C-string来构造string类对象 

string(const char* str)
	:_size(strlen(str))
	,_str(new char[strlen(str) + 1])
	,_capacity(strlen(str))

    {
    	strcpy(_str, str);
	}

 上述两者可以合并，写成一个全缺省的构造

string(const char* str = "")//不能给空指针，因为strlen会对指针进行解引用
	:_size(strlen(str))
{
	_capacity = _size;
	_str = new char[_capacity + 1];
	strcpy(_str, str);
}

3、拷贝构造：

拷贝构造可以使用两种方法。进行深拷贝，避免出现两个string指向同一个地址的情况。所谓传统写法，就是创建一个大小于s1相同的新空间，+1是因为capacity少了一个'\0'的大小。之后将新空间的地址拷贝给s2.

现代写法就是利用上面写的构造函数，构造一个内容和大小都与s1相同的临时函数tmp，之后交换给s2，而局部对象tmp出了作用域就销毁了。

string(const string& s)
{
	//s就是s1，this是s2
	
	//传统写法
	/*_str = new char[s._capacity + 1];
	strcpy(_str, s._str);
	_size = s._size;
	_capacity = s._capacity;*/

	//现代写法
	string tmp(s._str);//s._str是const char*类型，这一步相当于是用s1的地址创造了一个新空间并且里面有s1的内容
	swap(tmp);
}

 4、析构函数：

~string()
{
	delete[] _str;
	_str = nullptr;
	_size = _capacity = 0;
}

5、迭代器

不同对象的迭代器是不同的，也不只一种。

typedef char* iterator;
typedef const char* const_iterator;

const_iterator begin() const
{
	return _str;
}

const_iterator end() const
{
	return _str + _size;
}

iterator begin()
{
	return _str;
}

iterator end()
{
	return _str + _size;
}

 6、赋值：

 赋值同样有几种写法，传统写法就更加情绪，现代写法就更加简洁

//赋值s3 = s1,传统写法
//string& operator=(const string& s)
//{
//	char* tmp = new char[s._capacity];
//	strcpy(tmp, s._str);
//	delete[] _str;//这里清除的是s3，也就是被拷贝一方原有的内容
//	_str = tmp;
//	_size = s._size;
//	_capacity = s._capacity;
//	return *this;
//}

//赋值的现代写法
//string& operator=(const string& tmp)
//{
//	string ss(tmp);
//	swap(ss);//因为是局部对象，出了作用域会调用析构函数，就没了
//	return *this;
//}

//赋值现代写法进一步优化
string& operator=(string tmp)//从传址传参变为传值传参，会调用拷贝构造，就是现象了上面代码的第一行
{
	
	swap(tmp);
	return *this;
}

 7、遍历访问：

操作符重载，其中第一个函数是非常量成员函数，而第二个函数是常量成员函数用来给常量函数使用。

//遍历,访问
size_t size() const
{
	return _size;
}

size_t capacity() const
{
	return _capacity;
}

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

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

size_t	find(char ch, size_t pos=0)const
{
	assert(pos < _size);
	for (size_t i = pos; i < _size; i++)
	{
		if (_str[i] == ch) 
			return i;
		
	}
	return npos;
}

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

string substr(size_t pos = 0, size_t len = npos)
{
	string sub;
	if (len == npos || len >= _size - pos)
	{
		for (size_t i = pos; i < _size; i++)
		{
			sub += _str[i];
		}
	}
	else
	{
		for (size_t i = pos; i < len; i++)
		{
			sub += _str[i];
		}
	}
	return sub;
}

3、空间操作：

1、reserve：

void reserve(size_t n)
{
	if (n>_capacity)
	{
		char* tmp = new char[n+1];//开新空间
		strcpy(tmp, _str);//拷贝数据
		delete[] _str;//释放旧空间
		_str = tmp;//指向新地址

		_capacity = n;
	}
}

2、insert：

void insert(size_t pos, char ch)
{
	assert(pos <= _size);
	//扩容
	if (_size == _capacity)
	{
		reserve(_capacity == 0 ? 4 : 2 * _capacity);
	}

	/*int end = _size;
	while (end >= (int)pos)
	{
		_str[end + 1] = _str[end];
		--end;
	}
	_str[pos] = ch;
	++_size;*/

	//或者这样
	size_t end = _size+1;
	while (end > pos)
	{
		_str[end] = _str[end-1];
		--end;
	}
	_str[pos] = ch;
	++_size;
}

void insert(size_t pos, const char* str)
{
	assert(pos <= _size);
	size_t len = strlen(str);
	
	if (_size+len>_capacity)
	{
		//扩容
		reserve(_size + len);
	}
	size_t end = _size+len;
	while (end>=pos+len-1)
	{
		_str[end] = _str[end-len];
		end--;
	}
	strncpy(_str + pos, str, len);
	_size += len;
}

3、push_back:

void push_back(char ch)
{
	//扩容2倍
	/*if (_size == _capacity)
	{
		reserve(_capacity==0 ? 4:2 * _capacity);
	}

	_str[_size] = ch;
	++_size;
	_str[_size] = '\0';*/

	insert(_size, ch);
}

4、append：

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

5、运算符重载（+=）：

/*string& operator+=(const char* str)中的string& 表示返回一个对string类对象的引用，
而*this则是指向当前对象的指针。因此，return *this;表示返回当前对象的引用，
以便支持链式操作，即可以连续对同一个对象执行多次+=操作。*/
string& operator+=(char ch)
{
	push_back(ch);
	return *this;
}

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

6、resize：

void resize(size_t n, char ch = '\0')
{
	if (n<=_size)
	{
		_str[n+1] = '\0';
		_size = n;
	}
	else
	{
		reserve(n);
		for (size_t i = _size; i < n; i++)
		{
			_str[i] = ch;
		}
		_str[n] = '\0';
		_size = n;
	}
}

7、erase：

void erase(size_t pos, size_t len = npos)
{
	assert(pos < _size);
	if (len == npos || len >= _size-pos)//若(pos+len)>=_size则有溢出的风险
	{
		_str[pos] = '\0';
		_size = pos;
	}
	else
	{
		strcpy(_str + pos, _str+pos + len);
		_size -= len;
	}
}

8、swap：

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

void swap(string& x, string& y)//这是在类外面的两个字符串的交换
{
	x.swap(y);
}

4、清除（clear）：

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

5、运算符重载（比较大小）：

bool operator==(const string& s1, const string& s2)
{
	int ret = strcmp(s1.c_str(), s2.c_str());
	return ret == 0;
}

bool operator<(const string& s1, const string& s2)
{
	int ret = strcmp(s1.c_str(), s2.c_str());
	return ret < 0;
}

bool operator<=(const string& s1, const string& s2)
{
	return s1 < s2 || s1 == s2;
}

bool operator>(const string& s1, const string& s2)
{
	return !(s1 <= s2);
}

bool operator>=(const string& s1, const string& s2)
{
	return !(s1 < s2);
}

bool operator!=(const string& s1, const string& s2)
{
	return !(s1 == s2);
}

6、流输入流提取：

ostream& operator<<(ostream& out,const string& s)
{
	for (auto ch : s)//将字符串转变成一个一个字符，字符类型就成了内置类型，可以打印
	{
		out << ch;
	}
	return out;
}

istream& operator>>(istream& in, string& s)
{
	s.clear();
	char ch;
	//in >> ch;
	ch = in.get();
	char buff[128];
	size_t i = 0;
	while (ch != ' ' && ch!='\n')
	{
		buff[i++] = ch;
		if (i == 127)
		{
			buff[127] = '\0';
			s += buff;
			i = 0;
		}
		ch =in.get();
	}
	if (i>0)
	{
		buff[i] = '\0';
		s += buff;
	}
	return in;
}

istream& getline(istream& in, string& s)
{
	s.clear();
	char ch;
	//in >> ch;
	ch = in.get();
	while (ch != '\n')
	{
		s += ch;
		ch = in.get();
	}
	return in;
}

7、string类的整体实现：

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


namespace bit
{
	class string
	{
	public:

		//迭代器,不是所有的迭代器都是指针,迭代器不止一种
		typedef char* iterator;
		typedef const char* const_iterator;

		const_iterator begin() const
		{
			return _str;
		}

		const_iterator end() const
		{
			return _str + _size;
		}

		iterator begin()
		{
			return _str;
		}

		iterator end()
		{
			return _str + _size;
		}
		//无参的string
		//string()
		//	:_str(new char[1])
		//	,_size(0)
		//	,_capacity(0)
		//{
		//	_str[0] = '\0';
		//}
		带参的string
		//string(const char* str)
		//	:_size(strlen(str))
		//	,_str(new char[strlen(str) + 1])
		//	,_capacity(strlen(str))

		//{
		//	strcpy(_str, str);
		//}

		//合在一起,写一个全缺省参数
		string(const char* str = "")//不能给空指针，因为strlen会对指针进行解引用
			:_size(strlen(str))
		{
			_capacity = _size;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		//s2(s1)深拷贝
		string(const string& s)
		{
			//s就是s1，this是s2
			
			//传统写法
			/*_str = new char[s._capacity + 1];
			strcpy(_str, s._str);
			_size = s._size;
			_capacity = s._capacity;*/

			//现代写法
			string tmp(s._str);//s._str是cnnst char*类型，这一步相当于是用s1的地址创造了一个新空间并且里面有s1的内容
			swap(tmp);
		}

		//赋值s3 = s1,传统写法
		//string& operator=(const string& s)
		//{
		//	char* tmp = new char[s._capacity];
		//	strcpy(tmp, s._str);
		//	delete[] _str;//这里清除的是s3，也就是被拷贝一方原有的内容
		//	_str = tmp;
		//	_size = s._size;
		//	_capacity = s._capacity;
		//	return *this;
		//}

		//赋值的现代写法
		//string& operator=(const string& tmp)
		//{
		//	string ss(tmp);
		//	swap(ss);//因为是局部对象，出了作用域会调用析构函数，就没了
		//	return *this;
		//}

		//赋值现代写法进一步优化
		string& operator=(string tmp)//从传址传参变为传值传参，会调用拷贝构造，就是现象了上面代码的第一行
		{
			
			swap(tmp);
			return *this;
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
			_size = _capacity = 0;
		}

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

		//遍历,访问
		size_t size() const
		{
			return _size;
		}

		size_t capacity() const
		{
			return _capacity;
		}

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

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

		void reserve(size_t n)
		{
			if (n>_capacity)
			{
				char* tmp = new char[n+1];//开新空间
				strcpy(tmp, _str);//拷贝数据
				delete[] _str;//释放旧空间
				_str = tmp;//指向新地址

				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			//扩容2倍
			/*if (_size == _capacity)
			{
				reserve(_capacity==0 ? 4:2 * _capacity);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';*/

			insert(_size, ch);
		}

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

		/*string& operator+=(const char* str)中的string& 表示返回一个对string类对象的引用，
		而*this则是指向当前对象的指针。因此，return *this;表示返回当前对象的引用，
		以便支持链式操作，即可以连续对同一个对象执行多次+=操作。*/
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

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

		void resize(size_t n, char ch = '\0')
		{
			if (n<=_size)
			{
				_str[n+1] = '\0';
				_size = n;
			}
			else
			{
				reserve(n);
				for (size_t i = _size; i < n; i++)
				{
					_str[i] = ch;
				}
				_str[n] = '\0';
				_size = n;
			}
		}

		void insert(size_t pos, char ch)
		{
			assert(pos <= _size);
			//扩容
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : 2 * _capacity);
			}

			/*int end = _size;
			while (end >= (int)pos)
			{
				_str[end + 1] = _str[end];
				--end;
			}
			_str[pos] = ch;
			++_size;*/

			//或者这样
			size_t end = _size+1;
			while (end > pos)
			{
				_str[end] = _str[end-1];
				--end;
			}
			_str[pos] = ch;
			++_size;
		}

		
		void insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			size_t len = strlen(str);
			
			if (_size+len>_capacity)
			{
				//扩容
				reserve(_size + len);
			}
			size_t end = _size+len;
			while (end>=pos+len-1)
			{
				_str[end] = _str[end-len];
				end--;
			}
			strncpy(_str + pos, str, len);
			_size += len;
		}

		void erase(size_t pos, size_t len = npos)
		{
			assert(pos < _size);
			if (len == npos || len >= _size-pos)//若(pos+len)>=_size则有溢出的风险
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{
				strcpy(_str + pos, _str+pos + len);
				_size -= len;
			}
		}

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

		

		size_t	find(char ch, size_t pos=0)const
		{
			assert(pos < _size);
			for (size_t i = pos; i < _size; i++)
			{
				if (_str[i] == ch) 
					return i;
				
			}
			return npos;
		}

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

		string substr(size_t pos = 0, size_t len = npos)
		{
			string sub;
			if (len == npos || len >= _size - pos)
			{
				for (size_t i = pos; i < _size; i++)
				{
					sub += _str[i];
				}
			}
			else
			{
				for (size_t i = pos; i < len; i++)
				{
					sub += _str[i];
				}
			}
			return sub;
		}

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

	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0;

	public:
		static const int npos;
	};

	const int string::npos = -1;

	void swap(string& x, string& y)
	{
		x.swap(y);
	}

	bool operator==(const string& s1, const string& s2)
	{
		int ret = strcmp(s1.c_str(), s2.c_str());
		return ret == 0;
	}

	bool operator<(const string& s1, const string& s2)
	{
		int ret = strcmp(s1.c_str(), s2.c_str());
		return ret < 0;
	}
	
	bool operator<=(const string& s1, const string& s2)
	{
		return s1 < s2 || s1 == s2;
	}

	bool operator>(const string& s1, const string& s2)
	{
		return !(s1 <= s2);
	}

	bool operator>=(const string& s1, const string& s2)
	{
		return !(s1 < s2);
	}

	bool operator!=(const string& s1, const string& s2)
	{
		return !(s1 == s2);
	}

	

	ostream& operator<<(ostream& out,const string& s)
	{
		for (auto ch : s)//将字符串转变成一个一个字符，字符类型就成了内置类型，可以打印
		{
			out << ch;
		}
		return out;
	}
	
	istream& operator>>(istream& in, string& s)
	{
		s.clear();
		char ch;
		//in >> ch;
		ch = in.get();
		char buff[128];
		size_t i = 0;
		while (ch != ' ' && ch!='\n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				buff[127] = '\0';
				s += buff;
				i = 0;
			}
			ch =in.get();
		}
		if (i>0)
		{
			buff[i] = '\0';
			s += buff;
		}
		return in;
	}

	istream& getline(istream& in, string& s)
	{
		s.clear();
		char ch;
		//in >> ch;
		ch = in.get();
		while (ch != '\n')
		{
			s += ch;
			ch = in.get();
		}
		return in;
	}