前言
一、string
- （一）初始化、赋值、拼接
- （二）单个字符的访问和修改
- - []、at()
- （三）插入和删除
- - insert 、erase
- （四）查找和替换
- - find、rfind、replace
- （五）比较
- - compare
- （六）获取子串
- - substr
二、vector
- （一）初始化和赋值 --（4+3）
- - =、assign
- （二）访问数据 -- （4）
- - []、at()、front、back
- （三）插入、删除和清空
- - insert、erase、clear
- （四）大小和容量
- - size、capacity、resize
- （五）交换
- - swap
- （六）预开辟空间
- - reserve
三、deque
四、stack
五、queue
六、list
- 构造、赋值、交换、大小和容量、插入、删除和清空、访问数据、
七、set、multiset
- （一）初始化、赋值
- - =
- （二）插入、删除
- - insert、erase、clear
- （三）查找、统计
- - find、count
- （四）大小、交换
- - size、swap
- （五）排序
拓展：
- pair
八、map、multimap
- （一）初始化、赋值
- （二）插入、删除
- - insert、erase、clear
- （三）查找、统计
- - find、count
- （四）大小、交换
- - size、empty、swap
- （五）排序
总结

前言

打怪升级：第15天

一、string

string类对string变量、字符串（char*）以及单个字符（char）一般都有对应的函数。
string本质上就是字符串，内部原理是char*（了解过C语言的朋友应该可以更好地理解下面的内容）

（一）初始化、赋值、拼接

c++重载的函数是非常多的，我们需要做的是先来见识一番，之后根据自己的习惯和需求掌握其中几种即可。

//  string四种初始化方式
string s1;    //  无参构造
string s2("hello string");  //  使用字符串初始化
string s3(s2);       //  使用同为string的s2初始化（拷贝构造）
string s4(10, 'w');  //  使用字符初始化
// 补充： string s5(s2.substr(0,10));   拷贝构造：s2从下标为0的位置开始往后10个字符

示例：

// string赋值方式  --  对 operator= 的重载
char* str="hello string";
string s6;
s6=str;
s6=s2;
s6='w';

// 使用函数赋值  assign()
s6.assign(str);   //  使用字符串赋值
s6.assign(str, n1);  //  从下标为n1处开始
s6.assign(str, n1, n2); //  从下标为n1处开始，前n2个字符
s6.assign(s2);
//s6.assign(s2, n1);  这个函数在vs中可以使用，但是在Dev上识别不出来，应该是vs对assign函数做了扩展。
//s6.assign(s2, n1, n2);
s6.assign(10, 'w');

（二）单个字符的访问和修改

[]、at()

string s1("hello");
for(int i = 0; i < s1.size(); i++)
{
	cout << s1.at(i) << ' ';  // 等同于 s1[i] 
}
cout << endl;

（三）插入和删除

insert 、erase

	string s1("hello");
	s1.insert(s1.size(), " 靓仔");
	cout << s1 << endl;
	s1.erase(5, s1.size() - 5);   //  如果第二个数据大于后面剩余的字符个数，那就只会把后面的字符全部删掉
	cout << s1 << endl;

运行实例：

（四）查找和替换

find、rfind、replace

find函数在找不到时会返回 string::npos

string s7;
int pos = s7.find("bit", n1, n2);  // 在s7中，从下标为n1的位置开始，前n2个字符中是否存在字符串"bit"
									//	找到了返回下标，找不到就返回EOF
s7.rfind();      //   从右往左查找，找最后一次出现的位置
s7="abcdefghigklmn";
s7.replace(2, 0, "0000");     //  替换下标为2的位置0个字符为字符串"0000"，等价于：插入

运行实例：

（五）比较

compare

等于：返回 0
大于：返回 1
小于：返回 -1

void test05()
{
	string s1("hello");
	string s2("hello");
	cout << s1.compare(s2) << endl;
}

（六）获取子串

substr

	string s1 = "panda@csdn.com";
	int pos = s1.find('@');
	string s2 = s1.substr(0, pos);
	cout << "用户名：" << s2 << endl;

运行实例：

二、vector

不定长的单头数组

（一）初始化和赋值 --（4+3）

=、assign

	//  初始化    --  4种
	vector<int>v1;  //  无参构造

	vector<int>v2(v1);   //  拷贝构造

	vector<int>v3(v1.begin(), v1.end());  // 通过区间初始化

	vector<int>v4(10, 8);   //  使用n个数字初始化

	//   赋值   --  3种
	cout << "赋值" << endl;
	vector<int>v5;
	v5 = v1;       //  operator=            

	vector<int>v6;
	v6.assign(v1.begin(), v1.end());  //  assign()函数，区间赋值

	vector<int>v8;
	v8.assign(10, 8);    //  使用n个数字赋值

运行实例：

（二）访问数据 – （4）

[]、at()、front、back

vector<int>v1;
	InitVector(v1);
	// operator[]
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1[i] << ' ';
	}
	cout << endl;

	// at()
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1.at(i) << ' ';
	}
	cout << endl;

	// front(), back()
	cout << v1.front() << ' ' << v1.back() << endl;

	//补充： begin(), end()               iterator：迭代器
	for(vector<int>::iterator it = v1.begin(); it < v1.end(); it++)
	{
		cout << *it << ' ';
	}
	cout << endl;

运行实例：

（三）插入、删除和清空

insert、erase、clear

vector<int>v1;
	InitVector(v1);
	PrintVector(v1);
	v1.pop_back();     //  尾删
	PrintVector(v1);

	v1.insert(v1.begin() + 2, 10);  //  在下标为2的位置插入一个 10
	PrintVector(v1); 
	v1.insert(v1.begin(), 2, 100);  //  在最前面插入两个 100
	PrintVector(v1);
	v1.erase(v1.end() - 1);  //  删除最后一个位置的数据
	PrintVector(v1);
	v1.erase(v1.begin(), v1.begin() + 2); // 删除 [0,2)之间的数据
	PrintVector(v1);
	v1.clear();				 // 清空
	PrintVector(v1);

运行实例：

（四）大小和容量

size、capacity、resize

	vector<int>v1;
	InitVector(v1);
	v1.resize(12);    //  改变容器大小，空位默认用 0 填充
	bool temp = v1.empty(); //  判空
	cout << "size->" << v1.size() << endl;
	cout << "capacity->" << v1.capacity() << endl;
	v1.push_back(12);
	PrintVector(v1);

运行实例：

（五）交换

swap

	vector<int>v1;
	InitVector(v1);
	PrintVector(v1);
	vector<int>v2(6, 'w');
	PrintVector(v2);
	swap(v1, v2);
	PrintVector(v1);
	PrintVector(v2);

	// 收缩内存  --  借助匿名容器
	v1.assign(100000, 1);
	cout << "交换前：size->" << v1.size() << " capacity->" << v1.capacity() << endl;
	v1.resize(10);
	cout << "resize：size->" << v1.size() << " capacity->" << v1.capacity() << endl;
	vector<int>(v1).swap(v1);    //   匿名容器执行完当前语句后被系统回收
	cout << "交换后：size->" << v1.size() << " capacity->" << v1.capacity() << endl;

运行实例：

（六）预开辟空间

reserve

	cout << "系统自动更新capacity" << endl;
	vector<int>v1;
	int* pi = NULL;
	int num = 0;
	for (int i = 0; i < 100000; i++)
	{
		v1.push_back(i);
		if (pi != &v1[0])
		{
			pi = &v1[0];
			num++;
		}
	}
	cout << "重新开辟内存次数：" << num << endl;

	cout << "提前开辟好空间" << endl;
	vector<int>v2;
	v2.reserve(100000);  //  reserve是预开辟空间，但是实际大小还是0
	int* ppi = NULL;
	num = 0;
	for (int i = 0; i < 100000; i++)
	{
		v2.push_back(i);
		if (ppi != &v2[0])
		{
			ppi = &v2[0];
			num++;
		}
	}
	cout << "重新开辟内存次数：" << num << endl;

运行实例：

注意：如果发生了重新开辟内存，那么之前声明的迭代器就需要进行更新才能使用。

三、deque

双端数组（双端队列） – 操作选项同上面的vector

四、stack

栈：stack是一种非常简单的数据结构，只能从栈顶进出数据，
它和vector并不一样，
vector是一个数组，虽然是单端数组，但是数组有的操作vector也有，比如遍历、排序、POS位置的插入和删除等
而stack则有更多的限制，只能访问栈顶的数据，如果想要访问后面的数据就需要将栈顶数据出栈，那么栈顶数据就丢失了，
由于栈的限制很多，所以它操作起来非常简单。（因为它能做的操作少啊）

class Person
{
public:
	Person(string name, int age)
	{
		this->_name = name;
		this->_age = age;
	}

	string _name;
	int _age;
};

//  stack
void test03()
{
	stack<Person>s;
	Person p1("宁姚", 32);
	Person p2("陈平安", 33);
	Person p3("天真", 5000);
	s.push(p1);              // 入栈
	s.push(p2);
	s.push(p3);
	cout << "size->" << s.size() << endl;   //  获取大小
	while (!s.empty())  //  判空
	{
		cout << "name->" << s.top()._name << "\tage->" << s.top()._age << endl;   //  获取栈顶数据
		s.pop();       //  出栈
	}
	cout << "size->" << s.size() << endl;
}

举个栗子：

五、queue

队列：queue和stack一样也是很简单的容器，它的要求是只能在队头出数据，只能在队尾入数据。

六、list

链表：list （底层为双向循环链表）

构造、赋值、交换、大小和容量、插入、删除和清空、访问数据、

vector有的list基本上都有，并且用法完全相同（但是底层原理是不同的）。
list更多的操作：

删除：remove
翻转：reverse
排序：sort


bool Mycompare(int a, int b)
{
	// 升序
	//return a < b;

  //  降序
	return a > b;
}

void test04()
{
	list<int>l1;
	for (int i = 10; i > 5; i--)
	{
		l1.push_back(i);
		l1.push_front(1);
	}
	cout << "改变前：";
	for_each(l1.begin(), l1.end(), Print<int>);  // Print()是自己写的函数模板
	cout << endl;

	cout << "翻转后：";
	l1.reverse();     //   翻转
	for_each(l1.begin(), l1.end(), Print<int>);
	cout << endl;

	// 所有不支持随机访问的容器，不可以使用标准算法，既sort()，因此这里容器自己提供了 list.sort()算法
	// 对于自定义类型必须指定排序函数，不然编译器不知道如何排序
	cout << "升序列：";
	l1.sort();        //  排序  --  升序
	for_each(l1.begin(), l1.end(), Print<int>);
	cout << endl;

	cout << "降序列：";
	l1.sort(MyCompare);  //  排序  --  降序：自己提供一个排序函数
	for_each(l1.begin(), l1.end(), Print<int>);
	cout << endl;

	cout << "移除 1：";
	l1.remove(1);     //  移除
	for_each(l1.begin(), l1.end(), Print<int>);
	cout << endl;
}

运行实例：

list没有的操作：

对数据的访问：at()、[ ]
因为list底层是链表，无法像数组一样通过下标进行访问。

list<int>::iterator it = li.begin(); // iterator 是迭代器，这里it可以当做一个指针使用，但是它并不是指针
it = it + 1; //  error ，链表不支持随机访问
it++;   //  right
it--;   //  right， 双向链表可以找到前后节点
//  这里说的是设立的思想，不过至于为什么支持 ++ 不支持 it + 1，那是因为大佬们在设计的时候只重载了 ++，而没有重载 + 号，
//  这是为了防止使用者 有了 +1， 就想用 +2 、 +300等的随机访问操作，这在链表中是无法使用的。

七、set、multiset

集合：set – （底层为红黑树）
特点：在加入数据时会自动对数据进行排序，因此也叫关联式容器；
使用时只需包含头文件< set >；
set中不能出现重复的数据（重复数据不会被插入）；
multiset可以出现重复数据。

（一）初始化、赋值

=

set的初始化和赋值比较简单，初始化只有默认构造和拷贝构造，赋值只有：=

set<int>s1;    //  默认构造
set<int>s2(s1); // 拷贝构造

     //   赋值
set<int>s3;
s3=s2;

（二）插入、删除

insert、erase、clear

由于set在放入数据时会自动排序，无需设置将数据放到首部、尾部还是中间某个位置，
因此set容器放入数据只需要一个insert即可。

set<int>s4;
s4.insert(10);
s4.insert(20);
s4.insert(50);
s4.insert(40);
s4.insert(30);
for(set<int>::iterator it=s4.begin(); it!=s4.end(); ++it)
	cout<< *it<<' ';
	cout<<endl;

运行实例

（三）查找、统计

find、count

在set中由于不能出现重复数据，因此count（key）只有0或1两个值。

void test06()
{
    set<int>s;
    s.insert(1);
    s.insert(5);
    s.insert(4);
    s.insert(2);
    s.insert(3);
    set<int>::iterator it = s.find(2);
    if (it == s.end())
        cout << "did not find" << endl;
    else
        cout << *it << endl;

    it = s.find(20);
    if (it == s.end())
        cout << "did not find" << endl;
    else
        cout << *it << endl;
   
    cout << "number of 2->" << s.count(2) << endl;
}

运行实例：

（四）大小、交换

size、swap

（五）排序

set在插入数据时直接对数据进行排序，默认是升序序列，如果我们要改变排序规则就需要在插入数据之前进行，
这里我们可以写一个仿函数（重载小括号），这里需要将仿函数写在类里面，因为set后面的括号里需要的是一个类型。

class MyCompare
{
public:
	template<typename t>
	bool operator()(t v1, t v2)const  //  vs中这个 const不能省略
	{
		return v1 > v2;
	}
};

int main()
{
	set<int, MyCompare>s1;
	s1.insert(50);
	s1.insert(20);
	s1.insert(40);
	s1.insert(30);
	s1.insert(10);
	for (set<int, MyCompare>::iterator it = s1.begin(); it != s1.end(); it++)
		cout << *it << ' ';
	cout << endl;

	return 0;
}

结果：

对于自定义类型数据，我们必须设置比较函数

class Person
{
public:
	
	Person(string name, int age)
	{
		this->_name = name;
		this->_age = age;
	}
	
	string _name;
	int _age;
};

class MyCompare
{
public:
		bool operator()(const Person& s1, const Person& s2)const  //  const都不可省
	{
		return s1._name.compare(s2._name) >= 0;
	}
};

int main()
{
	set<Person, MyCompare>s2;
	Person p1("陈平安", 32);
	Person p2("宁姚", 31);
	Person p3("裴钱", 24);
	s2.insert(p1);
	s2.insert(p2);
	s2.insert(p3);
	for (set<Person, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++)
		cout << "name->" << (*it)._name << "age->" << it->_age << endl;
	return 0;
}

示例：

拓展：

pair

对组：pair，内置函数模板很少，这里我们了解一下它的初始化、赋值以及访问。

	vector<pair<string, int> >array;
    pair<string, int>Person("崔巉", 240);   //  初始化
    array.push_back(Person);
    Person = make_pair("左右", 230);   // 赋值
    array.push_back(Person);
    Person = make_pair("刘十六", 2000);
    array.push_back(Person);
    Person = make_pair("齐静春", 200);
    array.push_back(Person);
    Person = make_pair("老秀才", 300);
    array.push_back(Person);
    for(int i=0; i<array.size(); ++i)
    cout << array[i].first << ' ' << array[i].second << endl;  // 访问数据

运行实例：

八、map、multimap

图、查找表：map （底层为红黑树）
map中所以元素都是pair；
pair中的第一个元素为key（键值），起到索引作用，第二个元素为value（实值）；
map在插入数据时会按照键值进行升序排序，因此map也是关联式容器。
优点：
可以通过键值快速查找value。
map和multimap的区别：
map中不能出现重复的key，而multimap中可以（与set和multiset区别一样）；
注意这里只限制key，而map中如果出现重复的value是可以的。

（一）初始化、赋值

初始化：默认构造和拷贝构造
赋值：operator=

void PrintMap(map<const int, int>m)
{
    for (map<int, int>::iterator it = m.begin(); it != m.end(); ++it)
    {
        cout << "key->" << it->first << " value->" << it->second << endl;
    }
    cout << endl;
}

void test04()
{
    // 创建map数组  --  底层为二叉树
    map<const int, int>m1;   //  vs2022中不加const会报错
   // pair<int, int>tmp;
    //tmp = make_pair(4, 40);
    m1.insert(pair<const int, int> (1, 10)); // 插入数据，插入过程中会自动按照key值排序
    m1.insert(pair<const int, int>(4, 40));
    m1.insert(pair<const int, int>(2, 20));
    m1.insert(pair<const int, int>(3, 30));
    PrintMap(m1);

    map<const int, int>m2(m1);  //  拷贝构造
    PrintMap(m2);

    //  赋值
    map<const int, int>m3;
    m3 = m1;
    PrintMap(m3);
}

运行实例：

（二）插入、删除

insert、erase、clear

void test05()
{
    // 这里讲解4中插入的方法
    map<const int, int>m1;
    // 第一种
    m1.insert(pair<const int, int>(1, 10));
    // 第二种
    m1.insert(make_pair(3, 30));
    // 第三种
    m1.insert(map<const int, int>::value_type(2, 20));
    // 第四种
    m1[4] = 40;  //  key=4， value=40

    //  第四种一般用来插入数据，因为可以通过键值来访问value
    // 不建议用来访问数据，因为如果访问的键值不存在，编译器会自动创建 value为0的对组
    cout << m1[10] << endl;

    PrintMap(m1);
}

运行实例：

（三）查找、统计

find、count

同set

（四）大小、交换

size、empty、swap

同set

（五）排序

class MyCompare
{
public:
    bool operator()( int v1,  int v2)const
    {
        return v1 > v2;
    }
};

void test08()
{
    map<const int, int, MyCompare>m1;
    m1.insert(make_pair(1, 10));
    m1.insert(make_pair(2, 20));
    m1.insert(make_pair(3, 30));

    for (map<int, int, MyCompare>::iterator it = m1.begin(); it != m1.end(); ++it)
    {
        cout << "key->" << it->first << " value->" << it->second << endl;
    }
    cout << endl;
}

运行实例：

总结

查找：find
只有string类模板的find函数找到时返回值为下标，找不到则返回 string::npos
其他自带find函数以及标准函数返回值都为迭代器，找不到则返回 end() 。
单个数据访问：at
我们一般会觉得有了下标访问操作符就足够了，at会有些多余，
但是对于set、map这些容器是不能通过 [ ] 进行访问的，这时就需要at() 了，由此可知at() 更加通用。
迭代器
eg: vector v1;
vector::iterator it = v1.begin();
这里 it 就是一个迭代器，可以当做指针使用，但是实际上并不是指针，而是类模板，
迭代器通过重载指针的操作符 -> 、++、–等封装了一个指针；
是一个“可遍历STL（ Standard Template Library）容器内全部或部分元素”的对象。
因此 it 不能使用 NULL初始化，而且v1.begin() 的返回值也不能赋给整形指针。
参考文章：迭代器和指针
resize 和 reserve
resize是调整大小，往大了调整后空位默认补0，
reserve是预开辟空间，但是此时的大小时没有改变的，比如说：
你现在有100块钱，银行说可以给你贷款50万，那么这50万就是你可以使用的，但是这些钱实际上还是属于银行的，你实际拥有的钱只有100块，你去相亲的时候不能说你现在拥有50万存款，
这里也是一样的，我们重新创建的变量，此时size=0，我们reserve(100)，这是“贷款”，并不是真的给你100的内存空间，你的实际大小还是0，
只有使用resize(100)，调整了自身的大小之后才能够说我拥有50万的存款。
因此，在使用copy、merge等需要将数据移动到一个新的容器时，需要确保该容器拥有足够的空间，如果不够，就使用resize调整容器的大小。