string

什么是string

如图所示string这个模板实例化不是我们只学的那样，只有string，还有u16string，以及u32等，为什么会出现多种不同的实例化？
因为实际上互联网中大部分信息本质上的传输是以字符串的形式完成的，而由于世界上各国的文字类型又是不同的，最初的ASCII码是西方发明创造的，他们规定一个字符就是一个字节，而他们本身的文字也就是由一个一个字母所组成的，而我们中文的话，会非常的不方便，很多时候,如果写这样一个代码

string s = "大哥";

此时用编译器调试窗口监视的话

如果我采用代码cout<<s<<endl;
“大哥”两个字是可以被打印出来，但是通过窗口我们可以看到此时的具体元素都是？？？因为编译器无法解析我们的汉字，但打印的时候有可能有它自己的一套优化方式，所以可以出现正确的打印结果。
因此根据这种情况，string才有那么多种实例化种类
但是我们学的最多的还是最早的utf8

UTF-8（8位元，Universal Character Set/Unicode Transformation Format）是针对Unicode的一种可变长度字符编码。它可以用来表示Unicode标准中的任何字符，而且其编码中的第一个字节仍与ASCII相容，使得原来处理ASCII字符的软件无须或只进行少部分修改后，便可继续使用。因此，它逐渐成为电子邮件、网页及其他存储或传送文字的应用中，优先采用的编码。

所以string类是basic_string模板类的一个实例，它使用char来实例化basic_string模板类，并用char_traits和allocator作为basic_string的默认参数。

总结：
1.sting是表示字符串的字符串类
2.该类的接口与常规容器的接口基本相同，再添加了一些专门用来操作string的常规操作
3.string在底层实际是：basic_string模板类的别名，typedef basic_string<char,char_traits,allocator>string
4.不能操作多字节或者变长字符的序列
5. 注意，这个类独立于所使用的编码来处理字节:如果用来处理多字节或变长字符(如UTF-8)的序列，这个类的所有成员(如长度或大小)以及它的迭代器，将仍然按照字节(而不是实际编码的字符)来操作

迭代器

什么是迭代器？
迭代器是像指针一样的东西或者说就是指针，我们在string的模拟以及vector的模拟其迭代器就是用指针去typedef的
注迭代器是内嵌在类域当中的

定义必须是string::iterator it = s.begin()
或者 auto it = s.begin()

begin()代表的是有效数据的第一个位置
end() 代表有效数据结束位置的下一个位置

同时迭代器遍历的时候最好像我这样用

while (it != s1.end())
		//而不是这样写
		//while(it<s1.begin())
	{
		//内容
		it++;


	}

迭代器是指针一样的东西或者就是指针，string以及vector由于其物理储存的关系，他们迭代器所指向元素的位置begin()一定是小于end()，但是后续的链表，map等等容器，他们元素的地址都不是连续的,那么此时end()的地址不一定比begin()大，所以建议迭代器的遍历还是用

while(it!=s.end()
{
    //内容
    it++;
    
}

string元素的访问及遍历操作

由前述可知，string是表示字符串的字符串类，在C语言中，字符串的我们都是用[]完成的，而string想要满足和数组一样的操作，就必须使用运算符重载。

再次理解运算符重载： 在类和对象之前，使用的int,double,char，甚至是指针，他们统称为内置类型，但是之后我们使用的绝大多数类型都是自定义类型，自定义类型天生是不支持类似于内置类型那般+

• = []
  所以 运算符重载是为了让自定义类型让用户用上去与内置类型一样。

char& operator[](size_t pos)
		{
			//这边一定得注意，pos的位置一定要是合法的
			assert(pos < _size);
			return _str[pos];
		}

注意两点
1，只要是与pos位置有关的，我们就必须查看其是否越界

传统数组（C语言）越界检查是抽查行为，string的越界检查非常严格

2，为什么此时是传引用返回？？？
如果只是传值返回，那么此时返回的仅仅是_str[pos]的一份临时拷贝，出了作用域就会销毁，最主要的是，此时使用s[pos]无法修改它的值，而使用传引用返回，此时返回的是_str[pos]的一个别名，那么便可以支持s[pos] = "其他值“的操作
遍历string对象

string s = "Hello world!";
	for (size_t i = 0; i < s.size(); i++)
		cout << s[i] << " ";
	cout << endl;
	//迭代器遍历
	string::iterator it = s.begin();
	//也可以直接写auto it = s.begin() 编译器会自动推导类型
	while (it != s.end())
	{
		cout << *it << " ";
		it++;


	}
	cout << endl;

	//返回for
	for (auto e : s)
		cout << e << " ";
	cout << endl;

上述是上面代码的反汇编，通过反汇编可以看出，范围for的底层是迭代器，同时值得注意的是，范围for这个语法是C++11才支持的。
范围for的的底层其实也很简单，就是把it赋值给e,e就是it的临时拷贝，所以如果只是像上述那样，范围for是不能改变string中内容的，如果想要通过范围for改变string中的内容，只能添加引用，那么此时e就是*it的别称。

for (auto& e : s)
	{ 
		e += 1;
		cout << e << " ";

	}cout << endl;

**注意 **
范围for迭代器遍历时以实际的长度去遍历，例如
有一个string对象

string s = "sas   saaa"

如果是for迭代器遍历的话会将上述内容全部打印出来
但如果是cout<<s.str<<则是看’\0’结束的位置打印的

string s = "Hello world    sasasasa!";
	s += '\0';
	s += "asna";
	for (auto e : s)
	{ 
		//e += 1;
		cout << e ;

	}
	cout << endl;
	//Hello world    sasasasa!asna

	cout << s.c_str() << endl;

	//	Hello world    sasasasa!

reserve/resize/swap

上述函数都是string这个容器自带的函数
reserve/resize都是给string对象预开空间，因为如果一直插入元素时频繁扩容效率太低，所以如果我们一次性开较大空间可以提高程序的效率。
reserve：
只是开空间，eg：string s;s.reserve(100); 此时s的size()不变但是s.capacity()变成100
且reserve是不支持缩容的。
resize

string s = "Hello world!";
	//先打印出此时s的有效数据个数以及容量
	cout << "size:  " << s.size() << "--"<<"capacity:  " << s.capacity() << endl;
	//遍历此时的s
	for (auto e : s)
		cout << e << " ";
	cout << endl;
	
	//扩容,使得扩容后的大小比原来的大
	s.resize(100, 'G');//如果不注明后面补充的值，默认为'\0'
	cout << "size:  " << s.size() << "--" << "capacity:  " << s.capacity() << endl;
	//打印出此时s的有效数据个数以及容量
	//size:  100--capacity:  111

	//遍历此时的s
	for (auto e : s)
		cout << e << " ";
	cout << endl;
	//Hello world!GGG......GGGG
	//由于之前s中的有效元素个数是12个，所以此时由88个G来补位
	

	//缩容,使得扩容后的大小比原来的小
    //由于一开始s有效数据个数是12 所以我们先缩容到10
	s.resize(10);
	cout << "size:  " << s.size() << "--" << "capacity:  " << s.capacity() << endl;
	//打印出此时s的有效数据个数以及容量
	//size:  10--capacity:  111
	//发现此时size的个数为10，说明有效数据个数是10
	
	//遍历此时的s
	for (auto e : s)
		cout << e << " ";
	cout << endl;
	//遍历结果：H e l l o   w o r l

根据上述代码可知：
reserve不支持缩容，resize支持缩容
但是！！！
不建议缩容，因为缩容不是把原来申请的一部分数据还给操作系统
eg 假设我们已经申请了100个空间，但是我们现在要缩容到20个空间，此时系统的操作是先将20个空间拷贝到另外的空间上，再将原来的100个空间归还给操作系统，因为我们归还空间给操作系统是不允许一部分一部分归还的，好比不允许分期付款，这本身就是一个以时间换空间的行为，目前内存对我们而言成本大大减少，但是时间效率很重要，所以不提倡缩容！！！

string构造函数

构造函数与赋值运算符重载

/*string()
			:_size(0)
			, _capacity(0)
			,_str(nullptr)
		{

		}*/
		//如果是上述的默认构造函数那么下面这行代码便会直接报错
		// 因为此时会出现空指针解引用的情况
		//cout << d1.c_str() << endl;
		//此时我参考源代码发现虽然初始的时候string中没有字符
		//但是还是有一个空字符'\0'
		//则默认构造函数如下
		/*string()
			:_size(0)
			, _capacity(0)
		{
			_str = new char[1];
			_str[0] = '\0';
		}*/
		//或者直接将下列函数改成全缺省函数

		//string(const char* str)//构造函数
		string(const char* str = "")//此时表示如果不传参数的情况下是空格
			:_size(strlen(str))
			, _capacity(_size)
		{

			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		//拷贝构造
		string(const string& s)
			//:_str(new char[strlen(s._str) + 1])//先给需要拷贝的对象开辟空间
			:_size(strlen(s._str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, s._str);
		}

空指针的理解

空指针是有指向的，但它指向的地址是特殊的，该地址不经允许存放数据和不允许程序访问，所以空指针不能操作该地址的东西，我们就理解为”空指针指向了空，无法操作了“

拷贝构造(深拷贝)

string(const string& s)
			//:_str(new char[strlen(s._str) + 1])//先给需要拷贝的对象开辟空间
			:_size(strlen(s._str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, s._str);
		}

赋值运算符重载

//赋值运算符重载
		string& operator=(const string& s)
		{

			//思路：
			//赋值不像是拷贝构造，因为赋值的对象有可能本身就是有字符的
			//所以我们先要将赋值的对象delete
			if (this != &s)//如果是自己给自己赋值的话，如果我们先delete需要拷贝的对象，那么下面的代码都是
				//无效的，所以要有这个判断 
			{

				char* tam = new char[strlen(s._str) + 1];
				strcpy(tam, s._str);
				delete[]_str;
				_str = tam;
				_size = s._size;
				_capacity = s._capacity;
			}

			return *this;

		}

注意：
赋值运算符重载不是拷贝构造，需要被赋值的对象已经是存在的，所以还需要考虑到原本对象中已有内容，应先释放其空间中的内容，再给其拷贝，但同时还需要注意一个问题就是如果前面开辟空间失败的话即使抛异常，原本空间代码已经释放无法找回，所以此时添加一个临时变量，先将空间拷贝到临时变量上，没抛异常的话，再将此时临时变量指向的地址赋给原来的需要被赋值的对象。
切记此时千万不能直接拷贝构造
eg s1 = s3
若是空间太小，则有越界
若s1空间太大，则有空间浪费！

swap的探讨

string内有函数swap
但是c++模板库中也有swap函数

string s1 = "abcd";
	string s2 = "xxxx";
	s1.swap(s2);
	swap(s1, s2);

匿名对象的补充

创建对象的时候，只有创建对象语句，但是没有把对象赋值给某个变量。
注意匿名对象只能使用一次
适用场景：作为方法的参数和作为返回值

//作为方法参数
public static void main(String[] args){
        scannerDemo(new Scanner(System.in));
    }
    public static void scannerDemo(Scanner se){
        System.out.println("请输入一段文字:");
        String str = se.next();
        System.out.println(str);
    }

//作为返回值
public static void main(String[] args){
        System.out.println("请输入一个整数：");
        int num = scannerDemo().nextInt();
        System.out.println(num);
    }
    public static Scanner scannerDemo(){
        return new Scanner(System.in);
    }

匿名对象信息来源：点这里

string有关sizeof的补充

string整体实现

#pragma once
#include<assert.h>
#include<iostream>
using namespace std;


namespace zjt
{

	//需要考虑增删查改的string
	class string
	{
	public:

		//迭代器是像指针一样的东西或者就是指针
		//而string中的迭代器我们模拟实现就可以用指针模拟
		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()
			:_size(0)
			, _capacity(0)
			,_str(nullptr)
		{

		}*/
		//如果是上述的默认构造函数那么下面这行代码便会直接报错
		// 因为此时会出现空指针解引用的情况
		//cout << d1.c_str() << endl;
		//此时我参考源代码发现虽然初始的时候string中没有字符
		//但是还是有一个空字符'\0'
		//则默认构造函数如下
		/*string()
			:_size(0)
			, _capacity(0)
		{
			_str = new char[1];
			_str[0] = '\0';
		}*/
		//或者直接将下列函数改成全缺省函数

		//string(const char* str)//构造函数
		string(const char* str = "")//此时表示如果不传参数的情况下是空格
			:_size(strlen(str))
			, _capacity(_size)
		{

			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		//拷贝构造
		string(const string& s)
			//:_str(new char[strlen(s._str) + 1])//先给需要拷贝的对象开辟空间
			:_size(strlen(s._str))
			, _capacity(_size)
		{
			_str = new char[_capacity + 1];
			strcpy(_str, s._str);
		}

		//赋值运算符重载
		string& operator=(const string& s)
		{

			//思路：
			//赋值不像是拷贝构造，因为赋值的对象有可能本身就是有字符的
			//所以我们先要将赋值的对象delete
			if (this != &s)//如果是自己给自己赋值的话，如果我们先delete需要拷贝的对象，那么下面的代码都是
				//无效的，所以要有这个判断 
			{

				char* tam = new char[strlen(s._str) + 1];
				strcpy(tam, s._str);
				delete[]_str;
				_str = tam;
				_size = s._size;
				_capacity = s._capacity;
			}

			return *this;

		}

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

			}
		}
		char& operator[](size_t pos)
		{
			//这边一定得注意，pos的位置一定要是合法的
			assert(pos < _size);
			return _str[pos];
		}
		const char& operator[](size_t pos)const
		{
			//这边一定得注意，pos的位置一定要是合法的
			assert(pos < _size);
			return _str[pos];
		}

		size_t size()const//不涉及到成员变量的改变要加const
		{
			return _size;
		}
		size_t capacity()const
		{
			return _capacity;

		}
		const char* c_str()const//返回string指向字符串的地址
		{
			return _str;

		}

		//预开空间,但不会初始化
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tam = new char[n + 1];
				strcpy(tam, _str);
				delete[]_str;
				_str = tam;
				_capacity = n;


			}


		}
		//阔空间+初始化
		// 删除部分数据，保留前n个
		void resize(size_t n, char ch = '\0')
		{
			if (n < _size)//此时只保留前n个数据
			{
				_size = n;
				_str[n] = '\0';
			}
			//现在有两种情况
			//一种是此时n大于_capacity,一种是小于_capacity
			//
			else
			{
				if (n > _capacity)
					reserve(n);
				for (size_t i = _size; i < n; i++)
					_str[i] = ch;
				_size = n;
				_str[n] = '\0';


			}


		}
		//插入一个字符
		void push_back(char ch)
		{
			if (_size == _capacity)
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2 + 1);//开始初始化时要考虑到
			}
			_str[_size] = ch;
			_size++;
			_str[_size] = '\0';
		}
		//添加一个字符串
		void append(const char* str)
		{
			size_t len = _size + strlen(str);
			if (len > _capacity)//必须先判断是否需要扩容，否则会越界
				reserve(len);
			strcpy(_str + _size, str);
			_size = len;//一定要记得将这个_size = len
		}

		string& operator+=(const string& s)
		{
			append(s._str);
			return *this;
		}
		string& operator+=(const char ch)
		{
			push_back(ch);
			return *this;
		}
		//向string中插入一个字符
		string& insert(size_t pos, char ch)
		{
			//插入数据时一定要检测一下是否越界
			assert(pos << _size);
			//首先判断是否需要阔容
			if (_size == _capacity)
			{

				reserve(_capacity == 0 ? 4 : _capacity * 2);
			}

			size_t end = _size;
			while (end > pos)
			{
				_str[end] = _str[end - 1];
				--end;
			}
			_str[pos] = ch;
			++_size;
			return *this;
		}
		//向string中插入一个字符串
		string& insert(size_t pos, const char* str)
		{
			assert(pos <= _size);
			//要考虑到原来的string的容量是否满足插入字符串后的长度
			size_t len = strlen(str);
			if (_size + len > _capacity)//说明此时需要扩容
			{
				reserve(_size + len);
			}
			//接着将从pos位置开始的string中的字符依次往后移动len个位置

			size_t end = _size + len;
			while (end > pos + len - 1)
			{
				_str[end] = _str[end - len];
				--end;
			}
			//这边不能使用strcpy因为会将\0拷贝进去
			//此时我们便只能使用strncpy
			strncpy(_str + pos, str, len);
			_size += len;


			return *this;



		}

		//从pos位置开始删除len个字符且len默认值为size_t：-1
		string& earse(size_t pos, size_t len = npos)
		{
			assert(pos < _size);
			//此时分两种情况
			//1:从pos位置开始全部删完
			//2:从pos位置开始没有删完，pos位置删掉len个后
			//后面的字符全部往前移
			if (len == npos || pos + len > _size)
			{
				_str[pos] = '\0';
				_size = pos;
			}
			else
			{

				size_t end = pos + len;
				while (end <= _size)
				{
					_str[end - len] = _str[end];
					end++;
				}
				_size -= len;

			}

			return *this;


		}
		//从pos位置开始在string中找字符ch并且返回字符的下标
		size_t find(char ch, size_t pos = 0)
		{
			assert(pos < _size);
			for (size_t i = pos; i < _size; i++)
			{

				if (_str[i] == ch)
					return i;

			}
			return npos;

		}

		//从pos位置开始在string中找字符str并且返回最初的下标
		size_t find(const char* str, size_t pos = 0)
		{
			assert(pos < _size);
			const char* p = strstr(_str + pos, str);
			if (p == nullptr)
				return npos;
			else
				return p - _str;

		}

	private:
		char* _str;
		size_t _size;
		size_t _capacity;
		const static  size_t npos;

	};


	const size_t string::npos = -1;//实际上是最大值


	/*ostream& operator<<(ostream& out, const string& s)
	{
		for (auto ch : s)

		{
			out << ch;
		}

		return out;



	}*/
	//istream& operator >> (istream& in, string& s)
	//{

	//	/*char ch;
	//	ch = in.get();
	//	while (ch != ' ' && ch != '\n')
	//	{
	//		s += ch;
	//		ch = in.get();


	//	}*/
	//	//上面这种写法由于每次都要调用+=如果输入的字符串较长的话效率太低
	//	char ch;
	//	ch = in.get();
	//	char buff[128] = { '\0' };
	//	size_t i = 0;
	//	while (ch != ' ' && ch != '\n')
	//	{
	//		buff[i++] = ch;
	//		if (i == 127)

	//		{
	//			i = 0;

	//			s += buff;
	//			memset(buff, '\0', 128);

	//		}
	//		ch = in.get();

	//	}
	//	s += buff;




	//	return in;

	//}

	ostream& operator<<(ostream& out, const string& s)
	{
		for (auto ch : s)
		{
			out << ch;
		}

		return out;
	}

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

		//return in;

		char ch;
		ch = in.get();
		char buff[128] = { '\0' };
		size_t i = 0;
		while (ch != ' ' && ch != '\n')
		{
			buff[i++] = ch;
			if (i == 127)
			{
				s += buff;
				memset(buff, '\0', 128);
				i = 0;
			}

			ch = in.get();
		}

		s += buff;
		return in;
	}
	bool operator<(const string& s1, const string& s2)
	{
		return strcmp(s1.c_str(), s2.c_str()) < 0;




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




	}

	bool operator<=(const string& s1, const string& s2)
	{


		return s1 < s1 || 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);
	}



}