string类

        要介绍string类，就不得不提及STL了。

STL

概念

        STL(standard template libaray-标准模板库)：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。

组成

STL组成的六大组件

        其中，string类就属于STL中的一种容器。

string

        C语言中，字符串是以'\0'结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问,所以我们在C++中仍然需要学习string类。

string类的官方介绍

cplusplus.com/reference/string/string/?kw=string

auto

概念

1.在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，后来这个
不重要了。C++11中，标准委员会变废为宝赋予了auto全新的含义即：auto不再是一个存储类型
指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期
推导而得。
2.用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
3.当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。
4.auto不能作为函数的参数，可以做返回值，但是建议谨慎使用

5.auto不能直接用来声明数组

应用

auto可以作返回值，但建议谨慎使用
auto func3()
{
    return 3;
}

int a = 10;
auto b = a;
auto c = 'a';
auto d = func1();
 编译报错:rror C3531: “e”: 类型包含“auto”的符号必须具有初始值设定项
auto e;

此处修饰b的auto自动推导出其类型为int型，c为char型，d为函数返回值型，但是因为e没有给初始值，编译器无法推导，所以会报错.

范围for

概念

1.对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围
内用于迭代的变量，第二部分则表示被迭代的范围，自动迭代，自动取数据，自动判断结束。

2.范围for可以作用到数组和容器对象上进行遍历

3.范围for的底层很简单，容器遍历实际就是替换为迭代器，这个从汇编层也可以看到。

int main()
{

	int array[] = { 1, 2, 3, 4, 5 };
    
    原本写法
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
	{
		array[i] *= 2;
	}
	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
	{
		cout << array[i] << endl;
	}

	auto写法
	for (auto& e : array)
		e *= 2;
	for (auto e : array)
		cout << e << " " << endl;

	string str("hello world");
	for (auto ch : str)
	{
		cout << ch << " ";
	}
	cout << endl;

	return 0;
}

此时auto自动检测遍历数组为从头到尾顺序遍历.

string操作

string类对象的常见操作

void Teststring()
{
	string s1; // 构造空的string类对象s1
	string s2("hello bit"); // 构造string类对象s2
	string s3(s2); // 拷贝构造s3
}

string类的初始化操作

变量的声明

private:
	char* _str;
	size_t _capacity;
	size_t _size;

无参构造函数 （初始化列表）

string()
	:_str(new char[1]{"\0"})此处必须给一个空间，否则会报错
	,_size(0)
	,_capacity(0)
{
}

含参构造函数 

string(const char* str)
{
	_size = strlen(str);
	_capacity = _size;
	//capacity不包含"\0"
	_str = new char[_capacity + 1];
	strcpy(_str, str);
}

我们将其合二为一（无参与含参构造）

string(const char* str = "")常量字符串最后默认自带"\0"	
{
	_size = strlen(str);
	_capacity = _size;
	//capacity不包含"\0"
	_str = new char[_capacity + 1];
	strcpy(_str, str);会拷贝"\0"
}

析构函数

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

string类对象的容量操作

目录

注意：

1. size()与length()方法底层实现原理完全相同，引入size()的原因是为了与其他容器的接
口保持一致，一般情况下基本都是用size()。
2. clear()只是将string中有效字符清空，不改变底层空间大小。

3. resize(size_t n) 与 resize(size_t n, char c)都是将字符串中有效字符个数改变到n个，不
同的是当字符个数增多时：resize(n)用0来填充多出的元素空间，resize(size_t n, char
c)用字符c来填充多出的元素空间。注意：resize在改变元素个数时，如果是将元素个数
增多，可能会改变底层容量的大小，如果是将元素个数减少，底层空间总大小不变。

4. reserve(size_t res_arg=0)：为string预留空间，不改变有效元素个数，当reserve的参
数小于string的底层空间总大小时，reserver不会改变容量大小。

接下来，我们对其中几个重要的操作进行模拟实现

size

size_t size()const
{
	return _size;
}

capacity

size_t capacity()const
{
	return _capacity;
}

empty

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

reserve

void reserve(size_t newCapacity)
{
	// 如果新容量大于旧容量，则开辟空间
	if (newCapacity > _capacity)
	{
		char* str = new char[newCapacity + 1];
		strcpy(str, _str);

		// 释放原来旧空间,然后使用新空间
		delete[] _str;
		_str = str;
		_capacity = newCapacity;
	}
}

resize

void resize(size_t newSize, char c = '\0')
{
	if (newSize > _size)
	{
		// 如果newSize大于底层空间大小，则需要重新开辟空间
		if (newSize > _capacity)
		{
			reserve(newSize);
		}

		memset(_str + _size, c, newSize - _size);
	}

	_size = newSize;
	_str[newSize] = '\0';
}

string类对象的访问及遍历操作

目录

operator[]

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

const char& operator[](size_t pos)const//给const对象用，不能修改
{
	assert(pos < _size);
	return _str[pos];
}

iterator（迭代器）

typedef char* iterator;

iterator begin()
{
	return _str;
}

iterator end()
{
	return _str + _size;
}

string类对象的修改操作

目录

 push_back

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

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

operator+=

复用尾插函数
string& operator+=(char c)
{
	push_back(c);
	return *this;
}

c_str

const char* c_str()
{
	return _str;
}

string类非成员函数

目录

operator>>

istream& operator<<(istream& _cin, const Frenemy::string& s)
	{
		// 不能使用这个, 因为string的字符串内部可能会包含\0
		// 直接cout时, 是将_str当成char*打印的，遇到内部的\0时后序内容就不打印了
		//cin << s._str;
		for (size_t i = 0; i < s.size(); ++i)
		{
			_cin << s[i];
		}
		return _cin;
	}

operator<<

ostream& operator<<(ostream& _cout, const Frenemy::string& s)
	{
		// 不能使用这个, 因为string的字符串内部可能会包含\0
		// 直接cout时, 是将_str当成char*打印的，遇到内部的\0时后序内容就不打印了
		//cout << s._str;
		for (size_t i = 0; i < s.size(); ++i)
		{
			_cout << s[i];
		}
		return _cout;
	}

以上就是string中比较常用的函数实现. 

深浅拷贝

浅拷贝

        浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就会导致多个对象共享同一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知该
资源已经被释放，以为还有效，所以当继续对资源进项操作时，就会发生发生了访问违规。

深拷贝

        如果一个类中涉及到资源的管理，其拷贝构造函数、赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。 

        例如数据结构中的栈和队列这种需要调用资源的结构的实现，就需要专门写出深拷贝函数，如果依靠编译器自动调用的拷贝函数则很容易出现问题 .