C++学习第九篇（容器）

火星冲日

已于 2024-05-02 19:50:11 修改

阅读量391

点赞数 7

分类专栏： C++学习之路文章标签： c++ 学习笔记

于 2024-01-03 23:01:29 首次发布

本文链接：https://blog.csdn.net/qq_43472959/article/details/135372666

版权

C++学习之路专栏收录该内容

11 篇文章 0 订阅

订阅专栏

0，STL初识

STL（Standard Template Library）标准模板库，主要是为了提高数据结构和算法的复用性。

一，vector

0，可以理解为动态数组，简单用法：
（1）需要引入头文件< vector>；
（2）其底层实现较为复杂，可以用迭代器（可理解为指针）来执行遍历操作，下例中v.begin()指向的是首元素，v.end()指向的是最后一个元素的下一个位置（注意不可访问）；
（3）第三种遍历方法是采用了算法库（需要引入头文件algorithm）里的for_each，这个函数有三个参数，分别是迭代器的头、尾、需要对每个元素执行的操作函数名字；
（4）自动维护空间大小与位置，如果容量不够了，会自动找到新的位置，并把现有的数据都转移过去

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;
void printInt(int value) {
	cout << value << endl;
}
void test001() {
	vector<int> v;

	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);

	//遍历方式一：
	vector<int>::iterator itBegin = v.begin();
	vector<int>::iterator itEnd = v.end();
	cout << "第一种遍历方式：" << endl;
	while (itBegin != itEnd) {
		cout << *itBegin << endl;
		itBegin++;
	}
	//遍历方式二：
	cout << "第二种遍历方式：" << endl;
	for (vector<int>::iterator it = v.begin(); it != itEnd; it++) {
		cout << *it << endl;
	}

	//遍历方式三：
	cout << "第三种遍历方式：" << endl;
	for_each(v.begin(), v.end(), printInt);
}
int main() {
	test001();
}

1，构造函数
构造函数较多，灵活使用即可

vector<T> v;
vector(v.beg, v.end);
vector(n, elm);
vector(const vector& v);

2，赋值
主要重载运算符=，和assign（）函数

vector& operator=(const vector& v);
assign(v.beg, v.end);    //v容器的某一片段，beg和end表示这段的开始和结尾
assign(n, elm);          //n个元素elm赋值给本身

3，容量与大小
有一些常用操作，并且要注意这里有容量和实际的元素数量，这是两个不同的概念，一般容量是要大于元素数量。而且只能放大容量而不能收缩

empty();    //判断是否为空
capacity();  //当前容器的容量
size();   // 当前容器内元素数量
resize(int num); //重新指定容器的元素数量为num，若比现在大，新的空间会创建默认对象，若比现在小，其容量不变，只把元素数重置为num
resize(int num, elm);   //重新指定容器的元素数量为num，空的填充elm

4，插入和删除
常用的操作

push_back();  //往最后一个位置插入元素
pop_back();  //删掉最后一个元素
insert(const_iterator pos, elm);   //往迭代器位置插入元素
insert(const_iterator pos, int count, elm);   //往迭代器位置插入count个元素elm
erase(const_iterator pos);       //删掉迭代器位置的元素
erase(const_iterator start, const_iterator end);  //删除从start到end这段区间的元素
clear();    //清空容器

5，数据存取
常用操作，重载了运算符[]，也可以用at（）函数，注意这些返回的都是具体的元素，而不是迭代器指针

operator[]();
at();
front();    //返回首个元素
back();     //返回最后一个元素

6，容器互换
swap函数

swap()

由于vector基本只能放大容量而不能收缩，可以巧用swap函数来收缩，比如一个容器vector v，其容量很大，但实际只有三个元素，那么的大片的空间被浪费，可以这样操作：

vector<int>(v).swap(v);      // vector<int>(v), 这是由v进行的拷贝构造出的临时对象，这个对象会以v的实际大小（3）来构建，让这个对象与v互换，原本那么大的空间被标为了匿名空间，在这行代码执行完后被编译器清理掉，而v的大小与容量在swap之后，都变成了3

7，预留空间
如果预先知道了数据比较多，可以使用预留空间，如果慢慢插入数据，可能会重新开辟空间多次，并每次开辟空间，都会涉及到原本数据的迁移，开销较大，而reserve（）函数，只需要开辟一次空间。注意与resize（）函数的区别，resize（）函数会指定好新空间的大小，并且每块空间都会创建的有对象，而reserve（）只会预留空间，并不会往里面塞对象。

reserve(int n); //将其容量变为n

二，string容器

char* 是C的写法，本质是字符串的第一个字符指针；
string是C++写法，内部维护了一个char*，并提供了一些常用函数，也维护者其内存，不用担心越界情况，本质是一个类；

1，构造函数

string();                   //默认构造
string(const char*);        //使用字符串初始化
string(const string&);      //拷贝构造
string(int n ,char c);      //使用n个字符c来初始化

const char* str = "hello world";
string s1;
string s2(str);
string s3(s2);
string s4(4, 'a');  //4个a

2，赋值操作
多种重载，大致分为两类：（1），重载的=运算符；（2），assign（）函数

string& operator=(const char*s)
				 (const string& s)
				 (char c)         //将单个字符赋值给当前字符串
string& assign(const char* s)
			  (const char* s, int n) //将字符串s的前n个字符赋值给当前字符串
			  (const string& s)
			  (int n, char c)       //将n的字符串c赋值给当前字符串

3，字符串的拼接
多种重载，也是大致分为两类：（1），重载了+=操作符，这里解答了之前的一个疑惑，为什么不能像Java一样用+号来拼接字符串，因为C++没有重载（或者重载了但有别的用途？）；（2），append（）函数，这点倒是与Java一样。

string& operator+=(const char* str)
				  (const char c)
				  (const string& str)
string& append(const char* str)
			  (const char c)
			  (const string& str)
			  (const string& str, int pos, int n)  //把字符串从pos位置开始的n个字符拼接到当前字符串的末尾

4，字符串的查找和替换
（1）查找，一般都是返回第一次找到的位置，有从前往后查：find，和从后往前查：rfind，找到了则返回其索引，如果没找到，则返回-1

int find(const string& str, int pos = 0) const   //查找str第一次出现的位置，从pos位置开始查
		(const char* str, int pos = 0) const 
		(const char* str, int pos = 0, int n) const     //从pos位置开始，查找str的前n个字符串第一次出现的位置
		(const char c, int pos) const
int rfind(const string& str, int pos = npos) const //查找str最后出现的位置，从pos开始查
		 (const char* str, int pos = npos) const
		 (const char* str, int pos = npos, int n) const  //查找str的前n个字符最后出现的位置
		 (const char c, int pos = npos) const

（2）替换，不管替换前后字符串长度有无变化，一般都是给定一个要换的字符串，一个原字符串的起始位置和长度

string& replace(int pos, int n, const string& str)    //将原字符串，从pos开始的n个位置替换为str
			   (int pos, int n, const char* s)

5，字符串的比较
逐个比较字符的ASCLL值，大于返回1，等于返回0，小于返回-1，主要是看是否相等。

str1.compare(const string& str2) const
		    (const  char* s2) const

6，字符串的存取
C++风格的字符串string重写了[]操作符，所以可以像用数组一样去存取，当然也像Java一样提供了函数，二者都可以存或取。

char& operator[](int n)
char& at(int n)

7，字符串的插入和删除
insert函数用于插入，erase函数用于删除

string& insert(int pos, const string& str)        //在pos位置插入一个字符串
			  (int pos, const char* s)
			  (int pos, int n, char c)            //在pos位置插入n个字符c
strint& erase(int pos, int n = npos)      //从pos开始删掉n个字符

8，子串截取
substr函数用于截取子串

string substr(int pos = 0, int n = npos) const   //表示截图从pos开始的n个字符串组成的子串

三，deque容器

双端队列，但也支持随机访问，对于头部的插入和删除比vector快，因为vector对于头部的插入和删除会移动后面的数据，虽然也支持随机访问，但随机访问速度比vector慢；
deque内部有中控器来维护空间
deque没有容量的概念
在这里插入图片描述

1，构造函数

deque<T> dequeT;  //默认构造
deque(beg, end) dequeT; //以迭代器区间来构造
deque(n, elm);     //n个元素elm构造
deque(const deque<T>& d);   //拷贝构造

2，deque赋值

deque& operator=(const deque<T>& deq); //重载=运算符
assign(beg, end); //将区间[beg, end]中的值拷贝给本身
assign(n, elm);   //将n个elm赋值给本身

3，大小操作

deque.empty(); //判断是否为空
deque.size(); //查看元素数量
deque.resize(num);   //重新指定元素数量，若变长，新的位置以默认元素填充，若变短，后面的将会被移除
deque.resize(num, elm); //重新指定元素数量，若变长，新的位置以elm填充，若变短，后面的将会被移除

4，插入和删除
与vector的主要区别是增加了对头部的操作
双端操作：

push_back(elm);
push_front(elm);      //头插
pop_back();   //删除最后一个元素
pop_front();  //删除第一个元素

指定位置操作：

deque<T>::iterator insert(pos, elm); //指定位置插入元素elm，返回新元素的位置
void insert(pos ,n ,elm); //指定位置插入n个元素elm，无返回值
void insert(pos, beg, end);  //指定位置插入[beg, end]区间内的元素，无返回值
clear();  //清空元素
erase(beg, end); //擦掉[beg, end]元素
erase(pos);   //擦掉pos位置的元素

5，数据存取

at(int index);    //返回index位置处的元素，注意形参是索引不是迭代器
operator[];       //重载了操作符[]
front();          //获取头部元素
back();           //获取尾部元素

6，排序
注意这不是deque容器的成员函数，而是在STL中< algorithm >库的sort（）函数，默认升序

sort(iterator beg, iterator end);

四，stack容器

栈，遵循后进先出的顺序，只能对栈顶操作，因此不允许遍历

常用接口
构造

stack<T> stk; //默认构造
stack(const stack<T>& stk); //拷贝构造

赋值

stack& operator=(const stack<T>& stk);     //重载了运算符=

数据存取

push(elm);
pop();      //出栈
top();      //返回栈顶元素

大小操作

empty();
size();

五，queue容器

队列，先进先出；
与deque不同是，只有队尾才能入队，队头才能出队，而deque两端都可以入队出队；
不支持随机访问，不允许遍历；
在这里插入图片描述
常用接口

构造函数

queue<T> que; //默认构造
queue<const queue<T>& queue>;   //拷贝构造

赋值

queue<T>& operator=(const queue<T>& que); //重载了=运算符

数据存取

push(elm);
pop();
front();
back();

大小操作

empty();
size();

六，list容器

双向循环链表，非连续空间，不支持随机访问，而Java中有连续的ArrayList和链表式的LinkedList
在这里插入图片描述
1，构造函数

list<T> list1;
list(beg, end);
list(n, elm);
list(const list<T>& list1);

2，赋值和交换

assign(beg, end);
assign(n, elm);

list& operator=(const list<T>& list1);
swap(list1);

3，大小操作

empty();
size();
resize(num);   //若变长，多出的地方以默认元素填充；若变短，超出部分被删除
resize(num, elm); //若变长，多出的地方以elm填充；若变短，超出部分被删除

4，插入和删除

push_back(elm);
pop_back(); //删除最后一个元素
push_front(elm);
pop_front();

insert(pos, elm);
insert(pos, n, elm);
insert(pos, beg, end);

clear();
erase(pos);
erase(beg, end);

remove(elm); //移除容器中所有与elm匹配的元素

5，数据存取
因为是链表，所以不支持随机访问

front();
back();

6，反转和排序

reverse();    //反转， 比如1，2，3，4  反转后成4，3，2，1
sort();     //sort，这个sort来自标准算法库algorithm，不支持随机访问的容器不能用sort，因此这里不能用

list list1;
list1.sort();     //这个sort来自容器list的成员函数，可以用谓词自定义排序规则

自定义排序规则中案例，年龄升序，年龄相同的按身高降序：一个谓词即可搞定，不需要为年龄、身高分别写一个，然后先按身高降序，再按年龄升序排
在这里插入图片描述

七，set和multiset容器

关联式容器，即自动排序，底层使用二叉树实现；
set与multiset的区别：
1）set不允许重复元素，multiset允许
2）set插入元素时会返回插入结果，表示插入是否成功
3）multiset不会检测数据，因此可以重复

1，构造与赋值

set<T> set1;
set(const set<T>& set1);

set& operator=(const set<T>& set1);

2，大小和交换
resize(）默认使用0来填充，而set不允许重复，因此不提供resize（）函数来指定容量

size();
empty()
swap();

3，插入和删除
不提供尾插尾删类的，有insert（）函数

insert(elm);
clear();
erase(pos);  //删除迭代器pos所在位置的元素，返回下一个元素的迭代器
erase(beg, end);   //删除[beg, end]区间的元素，返回下一个元素的迭代器
erase(elm);      //删除某元素，类似list的remove()函数

4，查找和统计

find(elm); //返回指定元素的迭代器，找不到会返回end
count(elm); //统计容器中的elm元素数量

5，set容器自定义排序规则
在创建时，使用构造器的重载版本，使用仿函数来自定义规则，例如：

class MyCompare{
public:
    bool operator()(int value1, int value2){
    	return value1 > value2;       //降序
    }
}

void test(){
	set<int, MyCompare> set1;
	set1.insert(2);
	set1.insert(3);
	set1.insert(1);         //最终顺序：3，2，1
}

八，map和multimap容器

map容器所有元素都是pair，所有元素都会根据键值自动排序
关联式容器，底层使用二叉树实现
可以通过key快速找到value值

map和multimap的区别：
map不允许键值重复，multimap允许

对组pair：成对出现的数据，或者叫键值对
pair<type, type> p (key, value)；
pair<type, type> p = make_pair(key, value)；

获取第一个值：p.first
获取第二个值：p.second

1，构造和赋值

map<T1, T2> map1;
map(const map& map1);

map& operator=(const map& map1);

2，大小和交换

size();
empty();

swap();

3，插入和删除

insert(elm);
clear();
erase(elm);
erase(beg, end);
erase(key);        //删除键key对应的元素

其中在insert时又有几种写法：

map<int, int> m;
m.insert(pair<int, int>(1, 10));  //1，插入一个临时匿名对象pair，这个pair是（1，10）
m.insert(make_pair(2, 20));       //2，插入一个临时匿名对象pair，这个pair是（2，20）
m.insert(map<int, int>::value_type(3, 20)); //3，插入一个map内部提供的类型，这个pair是（3，30）
m[4] = 40;        //4，如果key = 4的元素不存在，插入{4， 40}，若存在修改其value = 40，不建议使用
cout << m[5] << endl;     //key = 5不存在，则会创建出来，其value使用默认值0，因此会打印0

4，查找和统计

find(key);     //查找key值对应的元素，若存在返回所在元素迭代器，不存在返回map.end()
count(key);    //统计key值对应元素数量，在map中不允许key重复，因此其结果为0或1

5，排序
在构建时使用重载构造器，利用仿函数，改变key值排序规则

class MyCompare{
public:
	bool operator()(int value1 ,int value2){
		return value1 > value2;         //降序
	}
}

void test(){
	map<int, int, MyCompare> m;
	m.insert(1, 10);
	m.insert(3, 30);
	m.insert(2, 20); //实际顺序为：{3，30}，{2，20}，{1，10}
}