STL核心知识总结（1）常用容器的用法

海岸星的清风

已于 2022-02-08 11:52:31 修改

阅读量1.6k

点赞数 1

分类专栏： C++ 文章标签：容器 c++

于 2022-02-06 22:05:14 首次发布

本文链接：https://blog.csdn.net/weixin_42461320/article/details/122802256

版权

C++ 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

string

string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。

构造函数

string s1; //创建空字符串，调用无参构造函数
	
const char* str = "hello world";
string s2(str); //把c_string转换成了string

string s3(s2); //调用拷贝构造函数

string s4(10, 'a');

赋值

	string str1;
	str1 = "hello world";

	string str2;
	str2 = str1;

	string str3;
	str3 = 'a';

	string str4;
	str4.assign("hello c++");

	string str5;
	str5.assign("hello c++",5);//取前五个字符
  
  string str6;
	str6.assign(str5);//等价于	str6 = str5;
  
  string str7;
	str7.assign(5, 'x');//赋值5个x

字符串拼接

 string str1 = "我";
 str1 += "爱玩游戏";
 str1 += ':';//拼接字符

	string str2 = "LOL DNF";
	str1 += str2;

	string str3 = "I";
	str3.append(" love ");
	str3.append("game abcde", 4);
  //截取前4个元素拼接
	//str3.append(str2);
	
  str3.append(str2, 4, 3); 
  // 从下标4位置开始 ，截取3个字符，拼接到字符串末尾

查找替换

  string str1 = "abcdefgde";
  int pos = str1.find("de");

	string str1 = "abcdefgde";
	str1.replace(1, 3, "1111");//从第1个位置开始3个字符替换为1111
  
/* find查找是从左往后，rfind从右往左
* find找到字符串后返回查找的第一个字符位置，找不到返回-1
* replace在替换时，要指定从哪个位置起，多少个字符，替换成什么样的字符串
*/

字符串比较

字符串比较是按字符的ASCII码进行对比。
= 返回 0；> 返回 1；< 返回 -1。

	int ret = s1.compare(s2);

字符存取

//字符读取
  string str = "hello world";

	for (int i = 0; i < str.size(); i++)
	{
		cout << str[i] << " ";
	}
	cout << endl;

	for (int i = 0; i < str.size(); i++)
	{
		cout << str.at(i) << " ";
	}
	cout << endl;


	//字符修改
	str[0] = 'x';
	str.at(1) = 'x';
	cout << str << endl;

插入和删除

	string str = "hello";
	str.insert(1, "111");
	str.erase(1, 3);  //从1号位置开始3个字符

字串

  string str = "abcdefg";
	string subStr = str.substr(1, 3);

	string email = "hello@sina.com";
	int pos = email.find("@");
	string username = email.substr(0, pos);//即找到邮件名，从0开始的pos个字符组成的字符串

vector

vector数据结构和数组非常相似，也称为单端数组，不同之处在于数组是静态空间，而vector可以动态扩展，即并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间。

构造

#include <vector>
//遍历函数
void printVector(vector<int>& v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) 
  {
		cout << *it << " ";
	}
	cout << endl;
}

void test01()
{
	vector<int> v1; //无参构造
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i);
	}
	printVector(v1);

	vector<int> v2(v1.begin(), v1.end());
	printVector(v2);

	vector<int> v3(10, 100);//构造函数将10个100拷贝给本身
	printVector(v3);
	
	vector<int> v4(v3);  //拷贝构造函数
	printVector(v4);
}
int main() {
	test01();
	system("pause");
	return 0;
}

赋值

使用=操作符或者v.assign(beg, end)

容量和大小

empty(); //判断容器是否为空
capacity(); //容器的容量
size(); //返回容器中元素的个数
resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。

//如果容器变短，则末尾超出容器长度的元素被删除。
resize(int num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。

//如果容器变短，则末尾超出容器长度的元素被删除

插入和杉树

	vector<int> v1;
	//尾插
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(40);
	v1.push_back(50);
	//尾删
	v1.pop_back();
	//插入
	v1.insert(v1.begin(), 100);//指定位置插入
	v1.insert(v1.begin(), 2, 1000);//指定位置插入2个
	//删除
	v1.erase(v1.begin());
	//清空
	v1.erase(v1.begin(), v1.end());
	v1.clear();

数据存取

除了用迭代器获取vector容器中元素，[ ]和at也可以
front返回容器第一个元素，v.front()
back返回容器最后一个元素，v.back()

互换

	v1.swap(v2);

预留空间

如果数据量较大，可以一开始利用reserve预留空间

reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。

deque

功能：

双端数组，可以对头端进行插入删除操作

deque与vector区别：

vector对于头部的插入、删除效率低，数据量越大，效率越低
deque相对而言，对头部的插入、删除速度比vector快
vector访问元素时的速度会比deque快，这和两者内部实现有关

deque内部工作原理:

deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据。

中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间。

deque容器的迭代器也是支持随机访问的

操作包括：赋值、大小操作、数据存取、排序（sort）。

stack

概念：stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口

栈中只有顶端的元素才可以被外界使用，因此栈不允许有遍历行为

栈中进入数据称为 — 入栈 push

栈中弹出数据称为 — 出栈 pop

操作包括：构造、赋值、数据存取、大小操作。
构造函数：

stack<T> stk; //stack采用模板类实现， stack对象的默认构造形式
stack(const stack &stk); //拷贝构造函数

赋值操作：

stack& operator=(const stack &stk); //重载等号操作符

数据存取：

push(elem); //向栈顶添加元素
pop(); //从栈顶移除第一个元素
top(); //返回栈顶元素

大小操作：

empty(); //判断堆栈是否为空
size(); //返回栈的大小

queue

概念：Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口

队列容器允许从一端新增元素，从另一端移除元素

队列中只有队头和队尾才可以被外界使用，因此队列不允许有遍历行为

队列中进数据称为 — 入队 push

队列中出数据称为 — 出队 pop

常用操作：
构造函数：

queue<T> que; //queue采用模板类实现，queue对象的默认构造形式
queue(const queue &que); //拷贝构造函数

赋值操作：

queue& operator=(const queue &que); //重载等号操作符

数据存取：

push(elem); //往队尾添加元素
pop(); //从队头移除第一个元素
back(); //返回最后一个元素
front(); //返回第一个元素

大小操作：

empty(); //判断堆栈是否为空
size(); //返回栈的大小

list

功能：将数据进行链式存储，形成链表。

链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。

STL中的链表是一个双向循环链表。

由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器

list的优点：

采用动态存储分配，不会造成内存浪费和溢出
链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

list的缺点：

链表灵活，但是空间(指针域) 和时间（遍历）额外耗费较大

List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。

总结：STL中List和vector是两个最常被使用的容器，各有优缺点

操作包括：构造、赋值、交换、大小操作、插入、删除、数据存取、反转、排序、

总结：

判断是否为空 — empty
返回元素个数 — size
重新指定个数 — resize

尾插 — push_back
尾删 — pop_back
头插 — push_front
头删 — pop_front
插入 — insert
删除 — erase
移除 — remove
清空 — clear
list容器中不可以通过[]或者at方式访问数据
返回第一个元素 — front
返回最后一个元素 — back
反转 — reverse
排序 — sort （成员函数）

set/ multiset

set：所有元素都会在插入时自动被排序。

本质：set/multiset属于关联式容器，底层结构是用二叉树实现。

set和multiset区别：

set不允许容器中有重复的元素
multiset允许容器中有重复的元素

常见操作包括：大小操作、交换、构造、赋值、插入、删除、查找、统计。

set容器插入数据时用insert
set容器插入数据的数据会自动排序
统计大小 — size
判断是否为空 — empty
交换容器 — swap
插入 — insert
删除 — erase
清空 — clear
查找 — find （返回的是迭代器）
统计 — count （对于set，结果为0或者1）

成对出现的数据，利用对组可以返回两个数据，两种创建方式：

pair<type, type> p ( value1, value2 );
pair<type, type> p = make_pair( value1, value2 );

	pair<string, int> p(string("Tom"), 20);
	pair<string, int> p2 = make_pair("Jerry", 10);

排序

set容器默认排序规则为从小到大，那如何实现从大到小排序呢？

利用仿函数，可以改变排序规则。

示例一：set存放内置数据类型

#include <set>

class MyCompare 
{
public:
	bool operator()(int v1, int v2) {
		return v1 > v2;
	}
};
void test01() 
{    
	set<int> s1;
	s1.insert(10);
	s1.insert(40);
	s1.insert(20);
	s1.insert(30);
	s1.insert(50);

	//默认从小到大
	for (set<int>::iterator it = s1.begin(); it != s1.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;

	//指定排序规则
	set<int,MyCompare> s2;
	s2.insert(10);
	s2.insert(40);
	s2.insert(20);
	s2.insert(30);
	s2.insert(50);

	for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

总结：利用仿函数可以指定set容器的排序规则

示例二 ：set存放自定义数据类型

#include <set>
#include <string>

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

	string m_Name;
	int m_Age;

};
class comparePerson
{
public:
	bool operator()(const Person& p1, const Person &p2)
	{
		//按照年龄进行排序  降序
		return p1.m_Age > p2.m_Age;
	}
};

void test01()
{
	set<Person, comparePerson> s;

	Person p1("刘备", 23);
	Person p2("关羽", 27);
	Person p3("张飞", 25);
	Person p4("赵云", 21);

	s.insert(p1);
	s.insert(p2);
	s.insert(p3);
	s.insert(p4);

	for (set<Person, comparePerson>::iterator it = s.begin(); it != s.end(); it++)
	{
		cout << "姓名： " << it->m_Name << " 年龄： " << it->m_Age << endl;
	}
}
int main() {

	test01();

	system("pause");

	return 0;
}

总结：对于自定义数据类型，set必须指定排序规则才可以插入数据

map/ multimap

简介：

map中所有元素都是pair，成对出现；
pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）；
所有元素都会根据元素的键值自动排序。

本质：

map/multimap属于关联式容器，底层结构是用二叉树实现。

优点：

可以根据key值快速找到value值

map和multimap区别：

map不允许容器中有重复key值元素
multimap允许容器中有重复key值元素

常见操作包括：大小操作、交换、构造、赋值、插入、删除、查找、统计。

构造和赋值

	map<int,int>m; //默认构造
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(2, 20));
	m.insert(pair<int, int>(3, 30));

	map<int, int>m2(m); //拷贝构造

	map<int, int>m3;
	m3 = m2; //赋值

总结：map中所有元素都是成对出现，插入数据时候要使用对组。

插入和删除

//插入
	map<int, int> m;
	//第一种插入方式
	m.insert(pair<int, int>(1, 10));
	//第二种插入方式
	m.insert(make_pair(2, 20));
	//第三种插入方式
	m.insert(map<int, int>::value_type(3, 30));
	//第四种插入方式
	m[4] = 40; 
	printMap(m);

	//删除
	m.erase(m.begin());
	printMap(m);

	m.erase(3);
	printMap(m);

	//清空
	m.erase(m.begin(),m.end());
	m.clear();
	printMap(m);

总结：

map插入方式很多，记住其一即可

插入 — insert
删除 — erase
清空 — clear
查找 — find （返回的是迭代器）
统计 — count （对于map，结果为0或者1）

map容器默认排序规则为：按照key值从小到大排序，如何从大到小排序呢？

利用仿函数，可以改变排序规则。

示例：

#include <map>

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

void test01() 
{
	//默认从小到大排序
	//利用仿函数实现从大到小排序
	map<int, int, MyCompare> m;

	m.insert(make_pair(1, 10));
	m.insert(make_pair(2, 20));
	m.insert(make_pair(3, 30));
	m.insert(make_pair(4, 40));
	m.insert(make_pair(5, 50));

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

	test01();

	system("pause");

	return 0;
}

总结：

利用仿函数可以指定map容器的排序规则
对于自定义数据类型，map必须要指定排序规则,同set容器

海岸星的清风

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
STL核心知识总结（1）常用容器的用法

目录stringvectordeque容器stackqueuelistset/ multisetmap/ multimapTips：在使用容器时，注意要添加相应的头文件，如#include<string>；STL的学习过程本质上就是学习数据结构与算法的过程，使用C++语言将常见的数据结构类型实现出来；各个容器包含的操作大同小异，一通百通。stringstring是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。构造函数string s1;
复制链接

扫一扫