STL

最新推荐文章于 2024-07-10 22:49:54 发布
最新推荐文章于 2024-07-10 22:49:54 发布
阅读量217 收藏
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51942099/article/details/115102068
版权

1. STL初识

STL基本概念：

1.STL从广义上分为容器、算法、迭代器
2.容器和算法之间通过迭代器进行了无缝连接
3.STL几乎所有的代码都采用了模板或者模板函数

STL的六大组件：容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

1.容器：各种数据结构，如vector、list、deque、set、map等用来存放数据
2.算法：各种常用的算法，如sort、find、copy、for_each等
3.迭代器：扮演了容器与算法之间的胶合剂
4.仿函数：行为类似函数，可作为算法的某种策略
5.适配器：一种用来修饰容器或者仿函数或迭代器接口的东西
6.空间适配器：负责空间的配置与管理

STL容器：

STL容器就是将运用最广泛的一些数据结构实现出来，常用的数据结构：数组、链表、树、栈、队列、集合等等。

容器分为序列式容器和关联式容器：

序列式容器：强调值的排序，序列式容器中的每个元素均有固定的位置
关联式容器：二叉树结构，各元素之间没有严格的物理上的顺序关系

算法（Algorithms）：

算法分为质变算法和非质变算法：

质变算法：是指运算过程中会更改区间内的元素的内容，例如拷贝、替换、删除等等
非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、寻找极值等

迭代器：

提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器内部表示方式，每个容器都有自己专属的迭代器

种类：
在这里插入图片描述
常用的有双向和随机访问迭代器

1.1 vector容器

vector的功能：vector数据结构和数组非常相似，也称为单端数组

vector与普通函数的区别：数组是静态空间，而vector可以动态扩展。所谓动态扩展并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝到新空间，释放原空间

注：vector容器的迭代器是支持随机访问的迭代器

在这里插入图片描述

1.1.1 vector存放内置数据类型

容器：vector
算法：for_each
迭代器：vector<int>::iterator

#include <iostream>
#include <vector>
#include <algorithm>//算法头文件
using namespace std;
void Print(int val) {
	cout << val << endl;
}
int main() {
	//创建了一个vector容器-数组
	vector<int>vec;
	//向容器中插入数据
	vec.push_back(10);
	vec.push_back(20);
	vec.push_back(30);
	vec.push_back(40);
	//通过迭代器访问容器中的数据
	/*vector<int>::iterator itBegin = vec.begin();//起始迭代器，指向容器中第一个元素
	vector<int>::iterator itEnd = vec.end();//结束迭代器，指向容器中最后一个元素的下一个位置
	//第一种遍历方式
	while (itBegin != itEnd) {
		cout << *itBegin << endl;
		itBegin++;
	}*/
	//第二种遍历方法：
	/*for (vector<int>::iterator it = vec.begin(); it != vec.end(); it++) {
		cout << *it << endl;
	}*/
	//第三种遍历方式:利用STL提供的遍历算法
	for_each(vec.begin(), vec.end(), Print);
}

vector存放自定义数据类型：

class Person {
public:
	Person(string name, int age) {
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;
};
void test1() {
	vector<Person>vec;
	Person p1("张三", 2);
	Person p2("李四", 3);
	vec.push_back(p1);
	vec.push_back(p2);
	for (vector<Person>::iterator it = vec.begin(); it != vec.end(); it++) {
		//cout << "姓名：" << (*it).m_name << "年龄:" << (*it).m_age << endl;//第一种方法
		cout << "姓名：" << it->m_name << "年龄:" << it->m_age << endl;
	}
}
//存放自定义数据类型指针
void test2() {
	vector<Person*>vec;
	Person p1("张三", 2);
	Person p2("李四", 3);
	vec.push_back(&p1);
	vec.push_back(&p2);
	//遍历容器
	for (vector<Person*>::iterator it = vec.begin(); it != vec.end(); it++) {
		cout << "姓名：" << (*it)->m_name << "年龄：" << (*it)->m_age << endl;
	}
}
int main() {
	test1();
	cout << "---------------" << endl;
	test2();
}
1.1.2 vector构造函数

函数原型：

vector<T> v;		//采用模板实现类实现，默认构造函数
vector(v.begin(), v.end());	//将[begin(), end())区间中的元素拷贝给本身
vector(n, elem);	//构造函数将n个elem拷贝给本身
vector(const vector &vec);//拷贝构造函数

void PrintV(vector<int>&v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << ' ';
	}
	cout << endl;
}
int main() {
	vector<int>v1;//默认构造
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	PrintV(v1);
	//通过区间的方式进行构造
	vector<int>v2(v1.begin(), v1.end());
	PrintV(v2);
	//n个elem方式构造
	vector<int>v3(10, 100);
	PrintV(v3);
	//拷贝构造
	vector<int>v4(v3);
	PrintV(v4);
}
1.1.3 vector赋值操作

功能描述：给vector容器进行赋值
函数原型：

vector& operator=(const vector& vec);//重载等号操作符
assign(beg, end);//将beg，end区间中的数据拷贝赋值给本身
assidn(n, elem);//将n个elem拷贝赋值给本身

void PrintV(vector<int>& v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}
int main() {
	vector<int>v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	PrintV(v1);
	//赋值 operator=
	vector<int>v2;
	v2 = v1;
	PrintV(v2);
	//assign方式赋值：
	vector<int>v3;
	v3.assign(v1.begin(), v1.end());
	PrintV(v3);
	//n个elem方式赋值
	vector<int>v4;
	v4.assign(10, 100);
	PrintV(v4);
}
1.1.4 vector容量和大小

功能描述：对vector容器的容量和大小操作

函数原型：

empty();//判断容器是否为空(空true)
capacity();//容器的容量
size();//返回容器中元素的个数
resize(int, num);//重新指定容器的长度为num，若容器变长，则可以默认值填充新位置；若容器变短，则末尾超出容器长度的元素被删除
resize(int num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置；如果容器变短，则末尾超出容器长度的元素被删除

void PrintV(vector<int>& v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}
int main() {
	vector<int>v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	PrintV(v1);
	if (v1.empty())cout << "v1为空" << endl;
	else {
		cout << "v1的容量为：" << v1.capacity() << endl;
		cout << "v1的大小为：" << v1.size() << endl;
	}
	v1.resize(15, 5);//重新指定大小
	PrintV(v1);
	v1.resize(5);
	PrintV(v1);
}
1.1.5 vector插入和删除

函数原型：

push_back(ele);//尾部插入元素ele
pop_back();//删除最后一个元素
insert(const_iterator pos, ele);//迭代器指向位置pos插入元素ele
insert(const_iterator pos, int count, ele)//迭代器指向位置pos插入count个元素ele
erase(const_iterator pos)//删除迭代器指向的元素
erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
clear();//删除容器中所有的元素

void PrintV(vector<int>& v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}
int main() {
	vector<int>v1;
	for (int i = 0; i < 5; i++) {
		v1.push_back(i);
	}
	PrintV(v1);
	v1.pop_back();//尾删
	PrintV(v1);
	v1.insert(v1.begin(), 100);//插入,第一个参数是迭代器
	PrintV(v1);
	v1.insert(v1.begin(), 2, 20);
	PrintV(v1);
	v1.erase(v1.begin());
	PrintV(v1);
	v1.erase(v1.begin() + 2);	//删除 参数是迭代器
	PrintV(v1);
	v1.erase(v1.begin(), v1.end() - 4);
	PrintV(v1);
	v1.erase(v1.begin(), v1.end());
	PrintV(v1);
}
1.1.6 vector数据存取

函数原型：

at(int index);//返回缩印index所指的数据
operator[];//返回缩印index所指的数据
front();//返回容器中第一个数据元素
back();//返回容器中最后一个数据元素

int main() {
	vector<int>v1;
	for (int i = 0; i < 5; i++) {
		v1.push_back(i);
	}
	for (int i = 0; i < v1.size(); i++) {//用[]方式访问数组中的元素
		cout << v1[i] << " ";
	}
	cout << endl;
	cout << v1[3] << endl;
	cout << v1.at(2) << endl;
	cout << "第一个元素：" << v1.front() << endl;
	cout << "最后一个元素：" << v1.back() << endl;
}
1.1.7 vector互换容器

函数原型：cppswap(vec);//将vec与本身的元素互换

void PrintV(vector<int>& v) {
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++){
		cout << *it << " ";
	}
	cout << endl;
}
void test() {
	//实际用途：巧用swap可以收缩内存空间
	vector<int>v;
	for (int i = 0; i < 100000; i++) {
		v.push_back(i);
	}
	cout << "v的容量：" << v.capacity() << endl;
	cout << "v的大小：" << v.size() << endl;
	v.resize(3);
	vector<int>(v).swap(v);//vector<int>(v)相当于是一个匿名对象，利用v创建了一个新的对象
	//用v初始化其大小和容量，这里容量个大小都初始化为3，执行完之后会被系统回收
	//.swap(v)做了一个容器的交换
	cout << "v的容量和大小为；" << v.capacity() << '\t' <<  v.size() << endl;
}
int main() {
	vector<int>v1;
	for (int i = 0; i < 5; i++) {
		v1.push_back(i);
	}
	PrintV(v1);
	vector<int>v2;
	for (int i = 10; i > 0; i--) {
		v2.push_back(i);
	}
	PrintV(v2);
	v1.swap(v2);//交换
	PrintV(v1);
	PrintV(v2);
	test();
}
1.1.8 vector预留空间

功能描述：减少vector在动态扩展容量时的扩展次数（如果数据较大，可以提前利用reserve预留空间）

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

int main() {
	int num = 0;//容量扩展的次数
	int* p = NULL;
	vector<int>v;
	v.reserve(100000);//利用reserve预留空间
	for (int i = 0; i < 100000; i++) {
		v.push_back(i);
		if (p != &v[0]) {
			p = &v[0];
			num++;
		}
	}
	cout << num << endl;//如果不提前预留空间，将扩展30次容量
}

1.2 string容器

string 和 char*的区别：

char* 是一个指针
string本质是一个类，类内部封装了char*，管理这个字符串，是一个char*型容器

特点：

1.string类内部封装了很多成员方法，如find、copy、delete等等
2.string管理char*所分配的内存，不用担心赋值越界和取值越界等，由内部进行负责

1.2.1 string构造函数

函数原型：

string();//创建一个空的字符串
string(const char* s);//使用字符串s初始化
string(const string& str);//使用一个string对象初始化另一个string对象
string(int n, char c);//使用n个字符c初始化

int main() {
	string s1;//默认构造
	const char* s= "hello world";
	string s2(s);
	cout << s2 << endl;
	string s3(s2);
	cout << s3 << endl;
	string s4(10, 'a');
	cout << s4 << endl;
}
1.2.2 string赋值操作

函数原型：

string& operator=(const char* s);//char*类型字符串赋值给当前字符串
string& operator=(const string& s);//把字符串赋值给当前的字符串
string& operator=(char c);//把字符赋值给当前的字符串
string& assign(const char* s);//把字符串s赋值给当前的字符串
string& assign(const char* s, int n);//把字符串s的前n个字符赋值给当前的字符串
string& assign(const string& s);//把字符串s赋值给当前字符串
string& assign(int n， char c);//用n个字符c赋给当前字符串

int main() {
	string str1;
	str1.assign("hello");
	cout << str1 << endl;
	string str2;
	str2.assign("hello world", 5);
	cout << str2 << endl;
	str2.assign(5, 'w');
	cout << str2 << endl;
}
1.2.3 string字符串拼接

函数原型：

string& operator+=(const char* str);//重载+=操作符
string& operator+=(const char c);
string& operator+=(const string& str);
string& append(const char* s);//把字符串s链接到当前字符串结尾
string& append(const char* s， int n);/把字符串s的前n个字符连接到当前字符串结尾
string& append(const string& s);
string& append(const string& s, int pos, int n);
//字符串s中从pos开始的n个字符连接到字符串结尾

int main() {
	string str1 = " hello";
	str1 += " world";
	cout << str1 << endl;
	string str2 = "!!";
	str1 += str2;
	cout << str1 << endl;

	string str3 = "I";
	str3.append(" LOVE");
	cout << str3 << endl;
	str3.append(" YOU and", 4);
	cout << str3 << endl;
	str3.append(str2);
	cout << str3 << endl;
	str3.append(str1, 7, 5);
	cout << str3 << endl;
}
1.2.4 string查找和替换

函数原型：

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

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

注：find和rfind的区别：find从左往右查找，rfind从右往左查找

int main() {
	string str1 = "abcdefgde";
	//find有一个返回值，返回被找到的字符串的下标（没找到就返回-1），这里用pos接收
	int pos = str1.find("de");//默认从0开始查找，
	if (pos == -1)cout << "未找到字符串" << endl;
	else cout << "找到的字符串的位置：" << pos << endl;
	//find和rfind的区别：find从左往右查找，rfind从右往左查找
	pos = str1.rfind("de");
	if (pos == -1)cout << "未找到字符串" << endl;
	else cout << "找到的字符串的位置：" << pos << endl;
	//替换
	string str2 = "abcdefg";
	//从1号位置开始，3个字符替换为“1111”
	str2.replace(1, 3, "1111");
	cout << str2 << endl;
}
1.2.5 string字符比较

比较方式：字符串比较是按照字符的ASCII码码进行比较，相等返回0，> 返回 1，< 返回 -1

函数原型：

int compare(const string& s) const;//与字符串s比较
int compare(const char* s) const;

string str1 = "hello";
string str2 = "hello";
if (str1.compare(str2) == 0) cout << "str1与str2相等" << endl;
else if(str1.compare(str2) > 0) cout << "str1大于str2" << endl;
else cout << "str1小于str2" << endl;
1.2.6 string字符存取

string中单个字符存取方式有两种：

char& operator[](int n);//通过[]方式存取
char& at(int n);//通过at方式存取

string str = "hello";
	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) << "  ";
	}
	str[0] = 'p';//修改
	str.at(1) = 'x';
1.2.7 string插入和删除

函数原型：

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

int main() {
	string str = "hello";
	//插入
	str.insert(1, "111");
	cout << str << endl;
	str.insert(1, 4, 's');
	cout << str << endl;
	//删除
	str.erase(1, 3);
	cout << str << endl;
}
1.2.8 string子串获取

函数原型：

string substr(int pos = 0, int n = npos)const;//返回由pos开始的n个字符组成的字符串

string str = "hello world";
	string subStr = str.substr(1, 3);
	cout << subStr << endl;

1.3 deque容器

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

deque与vector区别：

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

deque容器内部结构图：
在这里插入图片描述
deque容器内部工作原理：

deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据；中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的空间
在这里插入图片描述
注：deque容器的迭代器也是支持随机访问的

1.3.1 deque构造函数

功能：deque容器构造

函数原型：

deque<T>deqT;	//默认构造形式
deque(beg, end);//构造函数将(beg, end)区间中的元素拷贝给本身
deque(n, elem);//构造函数将n个elem拷贝给本身
deque(const deque& deq);//拷贝构造函数

void printDeque(const deque<int>& de)//只读
{//加上const之后，迭代器iterator必须变成const_iterator
	for (deque<int>::const_iterator it = de.begin(); it != de.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
int main()
{
	deque<int>de;
	for (int i = 0; i < 10; i++) {
		de.push_back(i);
	}
	printDeque(de);
	deque<int>de2(de.begin(), de.end());
	printDeque(de2);
	deque<int>de3(10, 5);
	printDeque(de3);
	return 0;
}
1.3.2 deque赋值操作

函数原型：

deque&operator=(const deque& deq);//重载等号操作符
assign(beg, end);//将每个（beg，end）区间中的数据拷贝赋值给本身
assign(n, elem);//将n个elem拷贝赋值给本身
1.3.3 deque大小操作

功能：对deque容器的大小进行操作

函数原型：

deque.empty();//判空
deque.size();//返回容器中元素的个数
deque.resize(num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置；若容器变短，则末尾超出容器长度的元素被删除
deque.resize(num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置；若容器变短，则末尾超出容器长度的元素被删除

注：deque没有容量的概念

1.3.4 deque插入和删除

两端插入操作：

push_back(elem);//尾插
push_front(elem);//头插
pop_back();//尾删
pop_front();//删除第一个数据

指定位置操作

insert(pos, elem);//在pos位置插入一个elem元素的拷贝，返回新数据的位置
insert(pos, n, elem);//在pos位置插入一个elem数据，无返回值
insert(pos, beg, end);//在pos位置插入[beg, end]区间的数据，无返回值
clear();//清空所有数据
erase(beg, end);//删除[beg, end]区间的数据，返回下一个数据的位置
erase(pos);//删除pos位置的数据，返回下一个数据的位置

void printDeque(const deque<int>& de)//只读
{
	for (deque<int>::const_iterator it = de.begin(); it != de.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
void test() {
	deque<int>d1;
	d1.push_back(1);
	d1.push_back(2);
	d1.insert(d1.begin(), 5);
	d1.insert(d1.begin(),2, 6);
	printDeque(d1);
	deque<int>d2;
	d2.push_back(10);
	d2.push_back(20);
	d2.push_back(30);
	d1.insert(d1.begin(), d2.begin(), d2.end());//按区间插入，此处为头部插入
	printDeque(d1);
}
void test1() {
	//删除
	deque<int>d3;
	d3.push_back(1);
	d3.push_back(2);
	d3.push_back(3);
	deque<int>::iterator it = d3.begin();
	it++;
	d3.erase(it);
	printDeque(d3);
	//按区间删除：
	//d3.erase(d3.begin(), d3.end());
	d3.clear();//清空
	printDeque(d3);
}
int main()
{
	deque<int>deq;
	deq.push_back(10);//尾插
	deq.push_back(20);
	deq.push_front(30);//头插
	printDeque(deq);
	deq.pop_back();//尾删
	deq.pop_front();//头删
	printDeque(deq);
	cout << "test:" << endl;
	test();
	cout << "test1:" << endl;
	test1();
	return 0;
}
1.3.5 deque数据存取

函数原型：

at(int, index);//返回索引为index所指的数据
operator[];//返回索引index所指的数据
front();//返回容器中第一个数据元素
back();//返回容器中最后一个数据元素

int main()
{
	deque<int>deq;
	deq.push_back(10);//尾插
	deq.push_back(20);
	deq.push_front(30);//头插
	for (int i = 0; i < deq.size(); i++) {
		cout << deq[i] << " ";
		//cout << deq.at(i) << endl;
	}
	cout << "第一个元素：" << deq.front() << endl;
	cout << "最后一个元素：" << deq.back() << endl;
	return 0;
}
1.3.6 deque排序
int main()
{
	deque<int>deq;
	deq.push_back(1);//尾插
	deq.push_back(2);
	deq.push_back(3);
	deq.push_front(4);//头插
	deq.push_front(6);
	deq.push_front(5);
	sort(deq.begin(), deq.end());//默认是从小到大
	for (deque<int>::const_iterator it = de.begin(); it != de.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
	return 0;
}

注：对于支持随机访问的迭代器的容器，都可以利用sort算法直接对其进行排序

案例：5名选手ABCDE，10个人评委为每一位选手打分，去除最高分和最低分，取平均分

#include <iostream>
#include <deque>
#include <vector>
#include <algorithm>
#include <string>
#include <ctime>
using namespace std;
//5名选手ABCDE，10个人评委为每一位选手打分，去除最高分和最低分，取平均分
class Person {
public:
	Person(string name, int score) {
		this->m_Name = name;
		this->m_Score = score;
	}
	string m_Name;//姓名
	int m_Score;//平均分
};
void creatPerson(vector<Person>& v) {
	string nameSeed = "ABCDE";
	for (int i = 0; i < 5; i++) {
		string name = "选手";
		name += nameSeed[i];
		int score = 0;
		Person p(name, score);
		v.push_back(p);//将创建的person对象放入到容器中
	}
}
void setScore(vector<Person>& v) {
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
		//将评委的分数放入deque容器中
		deque<int>deq;
		for (int i = 0; i < 10; i++) {
			int score = rand() % 41 + 60;
			deq.push_back(score);
		}
		cout << "选手：" << it->m_Name << "  打分：" << endl;
		for (deque<int>::iterator dit = deq.begin(); dit != deq.end(); dit++) {
			cout << *dit << " ";
		}
		cout << endl;
		sort(deq.begin(), deq.end());//排序
		deq.pop_back();
		deq.pop_front();
		int sum = 0;
		for (deque<int>::iterator dit = deq.begin(); dit != deq.end(); dit++) {
			sum += *dit;//总分
		}
		(*it).m_Score = sum / deq.size();
	}
}
void printScore(vector<Person>& v) {
	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) {
		cout << "选手：" << it->m_Name << "总分：" << it->m_Score << endl;
	}
}
int main()
{
	//随机数种子：
	srand((unsigned int)time(NULL));
	//1.创建5名选手
	vector<Person>v;
	creatPerson(v);
	//2.打分
	setScore(v);
	//3.输出最后得分
	printScore(v);
	return 0;
}

1.4 stack容器

stack是一种先进后出的数据结构，它只有一个出口

在这里插入图片描述
栈中进入数据称为入栈；栈中弹出数据称为出栈

注：栈中只有栈顶元素才能被外界访问，因此栈是不允许遍历的；栈可以判断容器是否为空，可以返回元素个数（在入栈的时候就可以统计进入元素个数）

stack常用接口

构造函数：

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

赋值操作：

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

数据存取：

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

大小操作：

empty();//判空
size();//返回栈的大小

void test() {
	//特点：符合先进后出数据结构
	stack<int>s;
	//入栈
	s.push(1);
	s.push(2);
	s.push(3);
	s.push(4);
	cout << "栈的大小：" << s.size() << endl;
	//只要栈不为空，查看栈顶，并且执行出栈
	while (!s.empty()) {
		//查看栈顶
		cout << "栈顶：" << s.top() << endl;
		//出栈
		s.pop();
	}
	cout << "栈的大小：" << s.size() << endl;
}
int main() {
	test();
	return 0;
}

1.5 queue容器

queue（又叫队列容器）是一种先进先出的数据结构，有两个出口

在这里插入图片描述
注

1.队列容器允许从一端新增元素，从另一端移除元素
2.队列中只有队头和队尾才可以被外界使用，因此队列不允许遍历
3.队列中进数据成为入队
4.队列中出数据成为出队

queue常用接口

构造函数：

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

赋值操作：

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

数据存取：

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

大小操作：

empty();//判空
size();//返回队列的大小

class Person {
public:
	Person(string name, int age) {
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;
};
int main() {
	queue<Person>q;
	Person p1("张三", 1);
	Person p2("李四", 2);
	Person p3("王五", 3);
	Person p4("麻子", 4);
	//入队
	q.push(p1);
	q.push(p2);
	q.push(p3);
	q.push(p4);
	//只要队列不为空，查看队头队尾
	while (!q.empty()) {
		cout << "队头姓名：" << q.front().m_name << "年龄：" << q.front().m_age << endl;
		cout << "队尾姓名：" << q.back().m_name << "年龄：" << q.back().m_age << endl;
		//出队
		q.pop();
	}
	cout << "队列大小" << q.size() << endl;
}

1.6 list容器

功能：将数据进行链式存储

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

链表组成：链表由一系列结点组成；结点：由存储数据元素的数据域和存储下一个结点地址的指针域组成

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

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

在这里插入图片描述
list的优点：

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

list的缺点：链表灵活，但是空间（指针域）和时间（遍历）额外耗费较大

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

1.6.1 list构造函数

功能创建list容器

函数原型：

list<T>list;//list采用模板类实现对象的默认构造形式
list(beg, end);//构造函数将[beg, end]区间中的元素拷贝给本身
list(n, elem);
list(const list& list);

void PrintList(const list<int>& l) {
	for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
int main()
{
	list<int>L;
	L.push_back(1);
	L.push_back(2);
	L.push_back(3);
	L.push_back(4);
	PrintList(L);//遍历
	list<int>L1(L.begin(), L.end());//区间方式构造
	PrintList(L1);
	list<int>L2(L);//拷贝构造
	PrintList(L2);
	list<int>L3(10, 10);//n个elem
	PrintList(L3);
	return 0;
}
1.6.2 list赋值和交换

函数原型：

assign(beg, end);//将beg，end区间中的数据拷贝赋值给本身
assign(n, elem);//将n个elem拷贝赋值给本身
list& operator=(const list& list);//重载等号操作符
swap(list);//将list与本身的元素互换

	list<int>L1;
	L1.push_back(1);
	L1.push_back(2);
	L1.push_back(3);
	L1.push_back(4);
	list<int>L2;
	//L2 = L1;//等号赋值
	//L2.assign(L1.begin(), L1.end());//区间赋值
	L2.assign(10, 5);
	L1.swap(L2);//两个容器的数据交换
1.6.3 list大小操作

函数原型：

size();//返回容器中元素的个数
empty();//判空
resize(num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置；若容器变短，则末尾超出容器长度的元素被删除
resize(num, elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置；若容器变短，则末尾超出容器长度的元素被删除
1.6.4 list插入和删除

函数原型：

push_back(elem);//尾插
pop_back();//尾删
push_front(elem);//头插
pop_front();//头删
insert(pos, elem);//在pos位置插入elem元素的拷贝，返回新数据的位置
insert(pos, n, elem);//在pos位置插入n个elem，无返回值
insert(pos, beg,end);//在pos位置插入[beg，end]区间的数据，无返回值
clear();//移除所有数据
erase(beg, end);//删除[beg, end]区间的数据，返回下一个数据的位置
erase(pos);//删除pos位置的数据，返回下一个数据的位置
remove(elem);//删除容器中所有与elem值匹配的元素

	list<int>L1;
	L1.push_back(1);
	L1.push_back(2);//尾插
	L1.push_back(3);
	L1.push_front(4);//头插
	L1.push_front(5);
	L1.push_front(6);
	L1.pop_back();//尾删
	L1.pop_front();//头删
	//在第一个后面插入元素
	L1.insert(++L1.begin(), 1000);
	L1.insert(++L1.begin(), 1000);
	L1.insert(++L1.begin(), 1000);
	L1.insert(++L1.begin(), 2000);
	L1.erase(L1.begin());//删除

	L1.remove(1000);//删除所有的1000元素
	L1.clear();//清空
1.6.5 list数据存取

函数原型：

front();//返回第一个元素
back();//返回最后一个元素

注：

  1. 不可以用中括号访问list容器中的个元素
  2. 不可以用at访问list中的元素
    原因是list本质是链表，不是用连续线性空间存储数据，迭代器也不支持随机访问
1.6.6 list反转和排序

函数原型 ：

reverse();//反转
sort();//排序

void PrintList(const list<int>& l) {
	for (list<int>::const_iterator it = l.begin(); it != l.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}
bool myCompare(int v1, int v2)
{
	//降序，就让第一个数大于第二个数
	return v1 > v2;
}
int main()
{
	list<int>L1;
	L1.push_back(1);
	L1.push_back(9);//尾插
	L1.push_back(6);
	L1.push_back(2);
	L1.push_back(7);
	L1.reverse();//反转
	PrintList(L1);
	//所有不支持随机访问迭代器的容器，不可以用标准算法
	//不支持随机访问迭代器的容器，内部都会提供对应的一些算法
	L1.sort();//默认排序规则从小到大
	PrintList(L1);
	L1.sort(myCompare);
	PrintList(L1);
	return 0; 
}
1.6.7 list排序案例

描述：将Person自定义数据类型进行排序，Person中属性有姓名，年龄，身高；
排序规则：按照年龄进行升序，如果年龄相同，按照身高进行降序

class Person {
public:
	Person(string name, int age, int height) {
		this->m_Name = name;
		this->m_Age = age;
		this->m_Height = height;
	}
	string m_Name;//姓名
	int m_Age;//年龄
	int m_Height;//身高
};
void PrintList(const list<Person>& L) {
	for (list<Person>::const_iterator it = L.begin(); it != L.end(); it++) {
		cout << "姓名：" << it->m_Name << " ";
		cout << "年龄：" << it->m_Age << " ";
		cout << "身高：" << it->m_Height << endl;
	}
}
bool comparePerson(Person& p1, Person& p2) {
	//按照年龄升序
	if (p1.m_Age == p2.m_Age)
		//年龄相同，按照身高降序
		return p1.m_Height > p2.m_Height;
	else
		return p1.m_Age < p2.m_Age;
}
int main()
{
	list<Person>L;
	Person p1("张三", 35, 175);
	Person p2("李四", 45, 180);
	Person p3("王五", 40, 170);
	Person p4("麻子", 25, 190);
	Person p5("赵六", 35, 160);
	Person p6("孙七", 35, 200);
	//插入数据
	L.push_back(p1);
	L.push_back(p2);
	L.push_back(p3);
	L.push_back(p4);
	L.push_back(p5);
	L.push_back(p6);
	PrintList(L);
	//排序：
	cout << "--------------排序后：---------------" << endl;
	L.sort(comparePerson);
	PrintList(L);
}

1.7 set / multiset 容器

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

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

set和multiset 区别：set不允许容器中有重复的元素，而multiset允许

1.7.1 set构造和赋值

函数原型：

set<T>st;//默认构造
set(const set& st);//拷贝构造
//赋值
set& operator=(const set& st);//重载等号操作符
1.7.2 set大小和交换

函数原型：

size();//返回容器中元素数目
empty();//判空
swap(st);//交换两个集合容器,

注：set容器不能重新指定大小

1.7.3 set插入和删除

函数原型：

insert(elem);//插入
clear();//清除所有元素
erase(pos);//删除pos迭代器所指的元素，返回下一个元素的迭代器
erase(beg, end);//删除区间[beg, end]的所有元素，返回下一个元素的迭代器
erase(elem);//删除容器中值为elem的元素

	set<int>st;
	st.insert(1);
	st.insert(3);
	st.insert(4);
	st.insert(2);
	cout << "st的大小：" << st.size() << endl;
	//删除
	st.erase(st.begin());
	st.erase(2);
	printSet(st);
	//清空
	//st.erase(st.begin(), st.end());
	st.clear();
1.7.4 set查找和统计

函数原型：

find(key);//查找key是否存在，若存在返回该元素的迭代器，若不存在返回set.end();
count(key);//统计key的元素个数

	set<int>st;
	st.insert(1);
	st.insert(3);
	st.insert(4);
	st.insert(2);
	set<int>::iterator pos = st.find(3);
	if (pos != st.end()) {
		cout << "找到元素：" << *pos << endl;
	}
	else {
		cout << "未找到元素" << endl;
	}
	//统计3的个数，，对于set而言，统计结果要么是0要么是1
	cout << "元素3的个数：" << st.count(3) << endl;
1.7.5 set和multiset区别

区别：

1.set不可以插入重复的数据，而multiset可以
2.set插入数据的同时会返回插入的结果，表示插入成功
3.multiset不会检测数据，因此可以插入重复的数据

	set<int>st;
	pair<set<int>::iterator, bool> ret = st.insert(1);
	if (ret.second) {
		cout << "第一次插入成功" << endl;
	}
	else {
		cout << "第一次插入失败" << endl;
	}
	ret = st.insert(1);//失败
	if (ret.second) {
		cout << "第二次插入成功" << endl;
	}
	else {
		cout << "第二次插入失败" << endl;
	}
	multiset<int>m;//允许插入重复的值
	m.insert(1);
	m.insert(1);
	m.insert(1);
	for (multiset<int>::iterator it = m.begin(); it != m.end(); it++) {
		cout << *it << " ";
	}
1.7.6 pair对组创建

对组（pair）的概念：

1.pair是将2个数据组合成一组数据，如stl中的map就是将key和value放在一起来保存，或者当一个函数需要返回2个数据的时候，也可以选择pair
2.pair的实现是一个结构体，主要的两个成员变量first和second，分别存储两个数据， 因为是使用struct不是class，所以可以直接使用pair的成员变量。

功能：成对出现的数据，利用对组可以返回两个数据

两种创建方式

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

	pair<string, int> p("张三", 20);//第一种方式
	cout << "姓名：" << p.first << " 年龄：" << p.second << endl;
	//第二种方式
	pair<string, int> p1 = make_pair("李四", 10);
	cout << "姓名：" << p1.first << " 年龄：" << p1.second << endl;
1.7.7 set排序

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

class Mycompare {
public:
	bool operator()(int v1, int v2) const {//仿函数
		return v1 > v2;
	}
};
int main()
{
	set<int>st;
	st.insert(1);
	st.insert(3);
	st.insert(4);
	st.insert(2);
	//默认排序 - 从小到大
	for (set<int>::iterator it = st.begin(); it != st.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
	//从大到小
	set<int, Mycompare>st2;
	st2.insert(1);
	st2.insert(3);
	st2.insert(4);
	st2.insert(2);
	for (set<int, Mycompare>::iterator it = st2.begin(); it != st2.end(); it++) {
		cout << *it << " ";
	}
}

set存放自定义数据类型

class Person {
public:
	Person(string name, int age) {
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;
};
class comparePreson {
public:
	bool operator()(const Person& p1, const Person& p2) const{
		return p1.m_age < p2.m_age;
	}
};
int main()
{
	//自定义的数据类型 必须要指定排序规则
	Person p1("张三", 43);
	Person p2("李四", 56);
	Person p3("王五", 45);
	Person p4("赵六", 98);
	set<Person, comparePreson>st;
	st.insert(p1);
	st.insert(p2);
	st.insert(p3);
	st.insert(p4);
	for (set<Person, comparePreson>::iterator it = st.begin(); it != st.end(); it++) {
		cout << "姓名：" << it->m_name << "  年龄：" << it->m_age << endl;
	}
}

1.8 map / multimap容器

map概念：

1.map中所有元素都是pair
2.pair中第一个元素为key（键值）， 起到索引作用，第二个元素为value（实值）
3.所有元素都会根据元素的键值自动排序

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

优点：可以根据key值快速找到value值

map和multimap区别：map不允许容器中有重复key值元素，而multimap允许

1.8 map构造和赋值

函数原型：

//构造：
map<T1, T2>mp;//map默认构造函数
map(const map& map);//拷贝构造函数
//赋值
map& operator=(const map& map);//重载等号操作符

void printSet(map<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;
}
int main()
{
	map<int, int>m;//按照key值排序
	//插入数据时要使用对组
	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(4, 20));
	m.insert(pair<int, int>(2, 30));
	m.insert(pair<int, int>(3, 40));
	printSet(m);
}
1.8.1 map大小和交换

函数原型：

size();//返回容器中元素的数目
empty();//判空
swap(mp);//交换两个容器
1.8.2map插入和删除

函数原型：

insert(elem);
clear();
erase(pos)//删除pos迭代器所知的元素，返回下一个元素的迭代器
erase(beg, end);//删除区间[beg, end]的所有元素，返回下一个元素的迭代器
erase(key);//删除容器中值为key的元素

void printSet(map<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;
}
int main()
{
	map<int, int>m;//按照key值排序
	m.insert(pair<int, int>(1, 10));
	m.insert(make_pair(2, 20));
	m.insert(map<int, int>::value_type(3, 30));//第三种]
	//[]不建议插入时使用，用法：可以利用key访问到已经创建好的value
	m[4] = 40;//第四种插入方法
	//cout << m[5] << endl;//第五个值没有，编译器会创建这个key个值，value为0
	cout << m[1] << endl;
	printSet(m);
	//删除，按照key值删除，不会按照value值删除
	m.erase(m.begin());
	m.erase(3);
	m.clear();
}
1.8.3 map查找和统计

函数原型：

find(key);//查找key是否存在，返回该键的元素的迭代器；若不存在，返回map.end();
count(key);//统计key的元素个数

	map<int, int>m;//按照key值排序
	m.insert(make_pair(1, 10));
	m.insert(make_pair(2, 20));
	m.insert(make_pair(4, 40));
	m.insert(make_pair(3, 30));
	map<int, int>::iterator pos = m.find(3);
	if (pos != m.end()) {
		cout << "查找到元素ky = " << pos->first << "  value = " << pos->second << endl;
	}
	else {
		cout << "没有查找到该元素" << endl;
	}
	//map不允许插入重复的key元素，count统计只有0或1
	//multimap可以大于1
	cout << m.count(3) << endl;
1.8.4 map排序

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

class compareMap {
public:
	//bool operator()(int v1, int v2)const 
	bool operator()(const int& v1, const int& v2)const {
		return v1 > v2;//从大到小排序
	}
};
void printSet(map<int, int, compareMap>& m)
{
	for (map<int, int, compareMap>::iterator it = m.begin(); it != m.end(); it++) {
		cout << "key = " << it->first << " value = " << it->second << endl;
	}
	cout << endl;
}
int main()
{
	map<int, int, compareMap>m;//按照key值排序
	m.insert(make_pair(1, 10));
	m.insert(make_pair(5, 50));
	m.insert(make_pair(2, 20));
	m.insert(make_pair(4, 40));
	m.insert(make_pair(3, 30));
	printSet(m);
}

注：对于自定义数据类型，map必须要指定排序规则，跟set容器类似

1.8.5 案例 - 员工分组

描述：
有10个员工（ABCDEFGHIJ），需要为员工分配部门；员工信息：姓名和工资；部门：策划、美术和研发；要求随机给10名员工分配部门和工资；通过multimap进行插入，key（部门编号）value（员工）；分部门的显示员工信息

实现步骤：

  • 创建10名员工，放入vector中；
  • 遍历vector容器，取出员工进行随机分组
  • 分组后，将部门编号作为key，具体员工作为value，放入multimap容器中
  • 分部门显示信息
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <ctime>
#define CEHUA 0
#define MEISHU 1
#define YANFA 2
using namespace std;
class Worker {
public:
	string m_Name;
	int m_Salary;
};
void creatWorker(vector<Worker>& v) {
	string nameSeed = "ABCDEFGHIJ";
	for (int i = 0; i < 10; i++) {
		Worker worker;
		worker.m_Name = "员工";
		worker.m_Name = nameSeed[i];
		worker.m_Salary = rand() % 10000 + 10000;//10000-19999
		//将员工放入到容器中
		v.push_back(worker);
	}
}
//员工分组
void setGroup(vector<Worker>& v, multimap<int, Worker>& m) {
	for (vector<Worker>::iterator it = v.begin(); it != v.end(); it++) {
		//产生随机部门编号
		int deptId = rand() % 3;//0 1 2
		//将员工插入到分组中
		m.insert(make_pair(deptId, *it));
	}
}
void showWorkerGroup(multimap<int, Worker>& m) {
	cout << "策划部门：" << endl;
	multimap<int, Worker>::iterator pos = m.find(CEHUA);
	int count = m.count(CEHUA);
	int index = 0;
	for (; pos != m.end() && index < count; pos++, index++) {
		cout << "姓名：" << pos->second.m_Name << "  工资：" << pos->second.m_Salary << endl;
	}
	cout << "----------------------" << endl;
	cout << "美术部门：" << endl;
	pos = m.find(MEISHU);
	count = m.count(MEISHU);
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++) {
		cout << "姓名：" << pos->second.m_Name << "  工资：" << pos->second.m_Salary << endl;
	}
	cout << "----------------------" << endl;
	cout << "研发部门：" << endl;
	pos = m.find(YANFA);
	count = m.count(YANFA);
	index = 0;
	for (; pos != m.end() && index < count; pos++, index++) {
		cout << "姓名：" << pos->second.m_Name << "  工资：" << pos->second.m_Salary << endl;
	}
}
int main() {
	srand((unsigned int)time(NULL));
	//创建员工
	vector<Worker>vWorker;
	creatWorker(vWorker);
	//员工分组
	multimap<int, Worker>mWorker;
	setGroup(vWorker, mWorker);
	//分组显示员工
	showWorkerGroup(mWorker);
}

2. STL - 函数对象

2.1 函数对象：

概念：

  • 重载函数调用操作符的类，其对象常称为函数对象
  • 函数对象使用重载的() 时，行为类似函数调用，也叫仿函数

本质：函数对象（仿函数）是一个类，不是一个函数

函数对象使用

特点：

1.函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
2.函数对象超出普通函数的概念，函数对象可以有自己的状态
3.函数对象可以作为参数传递

//1.函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
class Myadd {
public:
	int operator()(int v1, int v2) {
		return v1 + v2;
	}
};
//2.函数对象超出普通函数的概念，函数对象可以有自己的状态
class Myprint {
public:
	Myprint() {
		this->count = 0;
	}
	void operator()(string test) {
		cout << test << endl;
		count++;
	}
	int count;//内部自己的状态
};
//3.函数对象可以作为参数传递	
void doPrint(Myprint& mp, string test) {
	mp(test);
}
int main() {
	Myadd add;
	cout << add(10, 20) << endl;
	Myprint print;
	print("hello world!");
	print("hello world!");
	cout << "Myprint调用的次数：" << print.count << endl;
	//函数对象可以作为参数传递	
	doPrint(print, "hello world!");
}

3. 谓词

谓词概念：

  • 返回bool类型的仿函数称为谓词
  • 如果operator()接受一个参数，那么叫做一元谓词
  • 如果operator()接受二个参数，那么叫做二元谓词

3.1 一元谓词

class GreaterFive {
public:
	bool operator()(int val) {
		return val > 5;
	}
};
void test1() {
	vector<int>v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	//查找容器中大于5的数字
	//GreaterFive() 是匿名函数对象
	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());//按条件方式查找想要的结果
	if (it == v.end()) {
		cout << "未找到！" << endl;
	}
	else {
		cout << "找到大于5的数字为：" << *it << endl;
	}
}
int main() {
	test1();
}

3.2 二元谓词

class Compare {
public:
	bool operator()(int v1, int v2) {//传入两个参数
		return v1 > v2;
	}
};
int main() {
	vector<int>v;
	v.push_back(10);
	v.push_back(50);
	v.push_back(30);
	v.push_back(40);
	v.push_back(20);
	sort(v.begin(), v.end(), Compare());//排序，默认从小到大，此例设为降序
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
}

4. 内建函数对象

STL内部提供了一些仿函数；

分类：

  • 算术仿函数
  • 关系仿函数
  • 逻辑仿函数

用法：

  • 这些仿函数所残剩的对象，用法和一般函数完全相同
  • 使用内建函数对象，需要引入头文件#include <functional>

4.1 算术仿函数

功能描述：实现四则运算；其中negate是一元运算，其他都是二元运算

仿函数原型：

template<class T> T plus<T>	//加
template<class T> T minus<T>	//减
template<class T> T multiplies<T>	//乘
template<class T> T divides<T>	//除
template<class T> T modulus<T>	//取模
template<class T> T negate<T>	//取反仿函数

#include <iostream>
#include <functional>
using namespace std;
//一元取反仿函数
void test1() {
	negate<int>n;
	cout << n(50) << endl;
}
//二元仿函数 - 加
void test2() {
	plus<int>p;
	cout << p(10, 20) << endl;
}
int main() {
	test1();
	test2();
	return 0;
}

4.2 关系仿函数

仿函数原型：

template<class T> bool equal_to<T>	//等
template<class T> bool not_equal_to<T>	//不等
template<class T> bool greater<T>	//大于(常用)
template<class T> bool greater_equal<T>	//大于等于
template<class T> bool less<T>	//小于
template<class T> bool less_equal<T>	//小于等于

int main() {
	vector<int>v;
	v.push_back(1);
	v.push_back(3);
	v.push_back(5);
	v.push_back(2);
	v.push_back(4);
	//降序，使用内建函数对象greater<int>
	sort(v.begin(), v.end(), greater<int>());
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << endl;
	}
}

4.3 逻辑仿函数

仿函数原型：

template<class T> bool logical_and<T>	//与
template<class T> bool logical_or<T>	//或
template<class T> bool logical_not<T>	//非

int main() {
	vector<bool>v;
	v.push_back(true);
	v.push_back(false);
	v.push_back(true);
	v.push_back(false);
	for (vector<bool>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
	//利用逻辑非，将容器v搬运到容器v2中，并取反
	vector<bool>v2;
	v2.resize(v.size());//给v2容器开辟空间
	transform(v.begin(), v.end(), v2.begin(), logical_not<bool>());// 将容器v搬运到容器v2中
	for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++) {
		cout << *it << " ";
	}
}

5. STL - 常用算法

概述：

  • 算法主要由头文件<algorithm> <functional> <numeric>组成
  • <algorithm>是所有STL头文件中最大的一个，范围涉及到比较、交换、查找、遍历操作、复制、修改等
  • <numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数
  • <functional>定义了一些模板类，用以声明函数对象

5.1 STL - 常用遍历算法

算法：

for_each	//遍历容器
transform	//搬运容器到另一个容器中
5.1.1 for_each

函数原型：

for_each(iterator beg, iterator end, _func);
遍历容器元素；
beg开始迭代器，end结束迭代器，_func函数或者函数对象

//普通函数
void Print(int val) {
	cout << val << " ";
}
//仿函数
class Print01 {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};
int main() {
	vector<int>v;
	v.push_back(1);
	v.push_back(3);
	v.push_back(5);
	v.push_back(2);
	v.push_back(4);
	for_each(v.begin(), v.end(), Print);
	for_each(v.begin(), v.end(), Print01());
}
5.1.2 transfrom

函数原型

transfrom(iterator beg1, iterator end1, iterator beg2, _func);
beg1 源容器开始迭代器， end1源容器结束迭代器
beg2 目标容器开始迭代器， _func函数或者函数对象

class Transfrom {
public:
	int operator()(int v) {
		return v + 10;//在搬运时可以做运算
	}
};
//仿函数
class MyPrint {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};
int main() {
	vector<int>v;
	v.push_back(2);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(5);
	vector<int>v1;//目标容器
	v1.resize(v.size());//目标容器需要提前开辟空间
	transform(v.begin(), v.end(), v1.begin(), Transfrom());
	for_each(v1.begin(), v1.end(), MyPrint());
}

注：搬运的目标容器必须要提前开辟空间，否则无法正常搬运

5.2 STL - 常用查找算法

算法：

find			查找元素
find_if			按条件查找元素
adjacent_fine	查找相邻重复元素
binary_search	二分查找法
count			统计元素个数
count_if		按条件统计元素个数
5.2.1 find

功能：查找指定元素，找到返回指定元素的迭代器，找不到返回结束迭代器end()

函数原型：

find(iterator beg, iterator end, value);

class Person {
public:
	Person(string name, int age) {
		this->m_Name = name;
		this->m_Age = age;
	}
	//重载 == 告知底层的find知道如何对比Person数据类型
	bool operator==(const Person& p) {
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)return true;
		else return false;
	}
	string m_Name;
	int m_Age;
};
void test1() {
	vector<int>v;
	for (int i = 0; i < 20; i++) {
		v.push_back(i);
	}
	//查找容器中是否有5这个元素
	vector<int>::iterator pos = find(v.begin(), v.end(), 5);
	if (pos == v.end()) {
		cout << "没有找到5这个元素" << endl;
	}
	else {
		cout << "找到元素：" << *pos << endl;
	}
}
void test2() {
	//自定义数据类型
	Person p1("张三", 10);
	Person p2("李四", 20);
	Person p3("王五", 30);
	Person p4("麻子", 40);
	vector<Person>v;
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	//如果find查找的是自定义数据类型，必须要重载==操作符，因为底层无法比较自定义的数据类型
	vector<Person>::iterator pos = find(v.begin(), v.end(), p2);
	if (pos == v.end()) {
		cout << "没有找到元素" << endl;
	}
	else {
		cout << "找到元素 姓名：" << pos->m_Name << " 年龄：" << pos->m_Age << endl;
	}
}
int main() {
	test1();
	test2();
}
5.2.2 find_if

按条件查找元素

函数原型：

find_if(iterator beg, iterator end, _Pred);
_Pred    函数或者谓词（返回bool类型的仿函数）

class Greater {
public:
	bool operator()(int val) {
		return val > 5;
	}
};
//内置数据类型查找
void test1() {
	vector<int>v;
	for (int i = 0; i < 20; i++) {
		v.push_back(i);
	}
	//查找容器中是否有5这个元素
	vector<int>::iterator pos = find_if(v.begin(), v.end(), Greater());
	if (pos == v.end()) {
		cout << "没有找到" << endl;
	}
	else {
		cout << "找到大于5的元素：" << *pos << endl;
	}
}
//查找自定义数据类型
class Person {
public:
	Person(string name, int age) {
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};
class GreaterTow {
public:
	bool operator()(const Person& p) {
		return p.m_Age > 20;
	}
};
void test2() {
	Person p1("张三", 10);
	Person p2("李四", 20);
	Person p3("王五", 30);
	Person p4("麻子", 40);
	vector<Person>v;
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	//查找年龄大于20的人
	vector<Person>::iterator pos = find_if(v.begin(), v.end(), GreaterTow());
	if (pos == v.end()) {
		cout << "没有找到" << endl;
	}
	else {
		cout << "找到年龄大于20的人 姓名：" << pos->m_Name << " 年龄：" << pos->m_Age << endl;
	}
}
int main() {
	test1();
	test2();
}
5.2.3 adjacent_find

查找相邻重复元素

函数原型

adjacent_find(iterator beg, iterator end);
查找相邻重复元素，返回相邻元素的第一个位置的迭代器

vector<int>v;
	v.push_back(0);
	v.push_back(1);
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(0);
	v.push_back(0);
	v.push_back(4);
	vector<int>::iterator pos = adjacent_find(v.begin(), v.end());
	if (pos == v.end()) {
		cout << "没有找到" << endl;
	}
	else {
		cout << "找到相邻重复元素：" << *pos << endl;
	}
5.2.4 binary_search

查找指定元素是否存在

函数原型：

bool binary_search(iterator beg, iterator end, value);
查找到返回true，反之返回false

注：在无序序列中不可用

	vector<int>v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	bool ret = binary_search(v.begin(), v.end(), 9);
	if (ret == 0) {
		cout << "没有找到" << endl;
	}
	else {
		cout << "找到元素：" << endl;
	}
5.2.5 count

函数原型：

count(iterator beg, iterator end, value);
统计元素出现的次数

void test1() {
	vector<int>v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(1);
	v.push_back(2);
	int num = count(v.begin(), v.end(), 2);
	cout << "元素2 的个数：" << num << endl;
}
//自定义的数据类型：
class Person {
public:
	Person(string name, int age) {
		this->m_name = name;
		this->m_age = age;
	}
	bool operator==(const Person& p) {
		//如果要统计姓名或者年龄，只需要对比姓名或者年龄是否一样即可
		if (this->m_name == p.m_name && this->m_age == p.m_age) return true;
		else return false;
	}
	string m_name;
	int m_age;
};
void test2() {
	Person p1("张三", 10);
	Person p2("张三", 10);
	Person p3("李四", 20);
	Person p4("李四", 20);
	Person p5("张三", 20);
	Person p6("张三", 10);
	deque<Person>deq;
	deq.push_back(p1);
	deq.push_back(p2);
	deq.push_back(p3);
	deq.push_back(p4);
	deq.push_back(p5);
	deq.push_back(p6);
	int num = count(deq.begin(), deq.end(), p1);
	cout << "姓名和年龄都相同的人数为：" << num << endl;
}
int main() {
	test1();
	test2();
}
5.2.6 count_if

函数原型：

count_if(iterator beg, iterator end, _Pred);
按条件统计元素出现的次数，_Pred谓词

//提供仿函数
class Greater {
public:
	bool operator()(int val) {
		return val > 2;
	}
};
void test1() {
	//内置数据类型
	vector<int>v;
	v.push_back(1);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(2);
	v.push_back(3);
	v.push_back(4);
	v.push_back(2);
	int num = count_if(v.begin(), v.end(), Greater());
	cout << "大于2 的元素个数：" << num << endl;
}
//自定义的数据类型：
class Person {
public:
	Person(string name, int age) {
		this->m_name = name;
		this->m_age = age;
	}
	string m_name;
	int m_age;
};
class Greater1 {
public:
	bool operator()(const Person& p)const {
		return p.m_age > 20;
	}
};
void test2() {
	Person p1("张三", 35);
	Person p2("王五", 10);
	Person p3("李四", 40);
	Person p4("赵六", 30);
	Person p5("麻子", 25);
	deque<Person>deq;
	deq.push_back(p1);
	deq.push_back(p2);
	deq.push_back(p3);
	deq.push_back(p4);
	deq.push_back(p5);
	int num = count_if(deq.begin(), deq.end(), Greater1());
	cout << "年龄大于20的人数为：" << num << endl;
}
int main() {
	test1();
	test2();
}

5.3 STL - 常用排序算法

算法：

sort			对容器内元素进行排序
random_shuffle	洗牌，指定范围内的元素随机调整次序
merge			容器元素合并，并存储到另一容器中
reverse			反转指定范围的元素
5.3.1 sort

函数原型：

sort(iterator beg, iterator end, _Pred)
按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

void MyPrint(int val) {
	cout << val << " ";
}
int main() {
	vector<int>v;
	v.push_back(10);
	v.push_back(30);
	v.push_back(20);
	v.push_back(50);
	v.push_back(40);
	sort(v.begin(), v.end());//默认升序
	for_each(v.begin(), v.end(), MyPrint);//遍历输出
	cout << endl;
	cout << "--------降序----------" << endl;
	sort(v.begin(), v.end(), greater<int>());
	for_each(v.begin(), v.end(), MyPrint);
}
5.3.2 random_shuffle

函数原型：

random_shuffle(iterator beg, iterator end);
指定范围内的元素随机调整次序

#include <iostream>
#include <vector>
#include <ctime>
#include <algorithm>
using namespace std;
void MyPrint(int val) {
	cout << val << " ";
}
int main() {
	srand((unsigned int)time(NULL));//加入时间种子，每次洗牌的次序都不一样
	vector<int>v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i);
	}
	random_shuffle(v.begin(), v.end());
	for_each(v.begin(), v.end(), MyPrint);//遍历输出
	cout << endl;
}
5.3.3 merge

函数原型

merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
容器元素合并，并存储到另一容器中
dest 	目标容器开始迭代器

注：两个容器必须是有序的，并且顺序必须一致 - 同时为升 / 降，同时为降序时，要使用降序的函数对象 greater

void MyPrint(int val) {
	cout << val << " ";
}
int main() {
	vector<int>v1;
	vector<int>v2;
	//v1和v2顺序必须一致 - 同时为升 / 降
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i + 5);
	}
	//目标容器
	vector<int>vec;
	//提前给目标容器分配空间
	vec.resize(v1.size() + v2.size());
	merge(v1.begin(), v1.end(), v2.begin(), v2.end(), vec.begin());
	for_each(vec.begin(), vec.end(), MyPrint);//遍历输出
	cout << endl;
}
5.3.4 reverse

函数原型

reverse(iterator beg, iterator end);
反转指定范围的元素

void MyPrint(int val) {
	cout << val << " ";
}
int main() {
	vector<int>v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	reverse(v1.begin(), v1.end());//反转
	for_each(v1.begin(), v1.end(), MyPrint);//遍历输出
	cout << endl;
}

5.4 常用拷贝和替换算法

算法：

copy			容器内指定范围的元素拷贝到另一容器中
replace			将容器内指定范围的旧元素修改为新元素
replace_if		容器内指定范围满足条件的元素替换为新元素
swap			互换两个容器的元素
5.4.1 copy

函数原型：

copy(iterator beg, iterator end, iterator  dest);//dest  目标容器起始迭代器

vector<int>v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	vector<int>v2;
	v2.resize(v1.size());//开辟空间
	copy(v1.begin(), v1.end(), v2.begin());
5.4.2 replace

函数原型：

replace_if(iterator beg, iterator end, oldvalue, newvalue);
将区间内oldvalue 旧元素替换成newvalue 新元素

	vector<int>v1;
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(10);
	v1.push_back(10);
	replace(v1.begin(), v1.end(), 10, 100);//将10替换成100
5.4.3 replace_if

函数原型

replace_if(iterator beg, iterator end, _Pred, newvalue);
按条件替换元素，满足条件的替换成指定元素

class Greater {
public:
	bool operator()(int val) {
		return val > 10;
	}
};
class MyPrint {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};
int main() {
	vector<int>v1;
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(10);
	v1.push_back(20);
	v1.push_back(30);
	v1.push_back(20);
	replace_if(v1.begin(), v1.end(), Greater(), 100);//将大于10的替换成100
	for_each(v1.begin(), v1.end(), MyPrint());//遍历输出
}
5.4.4 swap

函数原型：

swap(container c1, container c2);
互换两个容器的元素	容器的类型要一样

5.5 常用算术生成算法

注：在使用算术生成算法时包含头的头文件为：#include <numeric>

算法：

accumulate		计算容器元素累计总和
fill			向容器中添加元素
5.5.1 accumulate

函数原型：

accumulate(iterator beg, iterator end, value);
value		起始累加值

	vector<int>v;
	for (int i = 0; i <= 100; i++) {
		v.push_back(i);
	}
	int num = accumulate(v.begin(), v.end(), 0);
	cout << num << endl;
5.5.2 fill

函数原型：

fill(iterator beg, iterator end, value);
向容器中添加指定的元素
value		填充的值

	vector<int>v;
	v.resize(10);
	//后期重新填充
	fill(v.begin(), v.end(), 5);
	for_each(v.begin(), v.end(), MyPrint());

5.6 常用集合算法

算法：

set_intersection		求两个容器的交集
set_union				求两个容器的并集
set_difference			求两个容器的差集
5.6.1 set_intersection

函数原型：

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
dest	目标容器开始迭代器

注：

  • 两个集合必须是有序序列
  • 目标容器开辟空间需要从两个容器中取小值
  • set_intersection返回值是交集中最后一个元素的位置
class MyPrint {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};
int main() {
	vector<int>v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
	}
	vector<int>v2;
	for (int i = 5; i < 15; i++) {
		v2.push_back(i);
	}
	vector<int>vec;
	//给目标容器开辟空间，最特殊的情况，大容器包含小容器，去小容器的size即可
	vec.resize(min(v1.size(), v2.size()));
	//获取交集，返回交集的结束迭代器
	vector<int>::iterator itEnd = set_intersection(v1.begin(), v1.end(), v2.begin(), v2.end(), vec.begin());
	for_each(vec.begin(), itEnd, MyPrint());
}
5.6.2 set_union

函数原型：

set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
dest	目标容器开始迭代器

注：

  • 两个集合必须是有序序列
  • 目标容器开辟空间需要两个容器的大小相加
  • set_union返回值是交集中最后一个元素的位置
class MyPrint {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};
int main() {
	vector<int>v1;
	vector<int>v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i + 5);
	}
	vector<int>vec;
	//最特殊的情况，两个容器没有交集，两个容器的size相加
	vec.resize(v1.size() + v2.size());
	//获取并集，返回并集的结束迭代器
	vector<int>::iterator itEnd = set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), vec.begin());
	for_each(vec.begin(), itEnd, MyPrint());
}
5.6.3 set_difference

函数原型

set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);
dest	目标容器开始迭代器

注：

  • 两个集合必须是有序序列
  • 目标容器开辟空间需要从两个容器中取大值
  • set_difference返回值是交集中最后一个元素的位置
class MyPrint {
public:
	void operator()(int val) {
		cout << val << " ";
	}
};
int main() {
	vector<int>v1;
	vector<int>v2;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i);
		v2.push_back(i + 5);
	}
	vector<int>vec;
	//最特殊的情况，两个容器没有交集，取两个容器中大的size
	vec.resize(max(v1.size(), v2.size()));
	//获取差集，返回差集的结束迭代器
	vector<int>::iterator itEnd = set_difference(v1.begin(), v1.end(), v2.begin(), v2.end(), vec.begin());
	cout << "v1和v2的差集：" << endl;
	for_each(vec.begin(), itEnd, MyPrint());
	cout << endl;
	itEnd = set_difference(v2.begin(), v2.end(), v1.begin(), v1.end(), vec.begin());
	cout << "v2和v1的差集：" << endl;
	for_each(vec.begin(), itEnd, MyPrint());
}

在这里插入图片描述

满月∅
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
浅谈STL
m0_52383532的博客
01-17 327
浅谈STL的理解 文录浅谈STL的理解前言一、STL是什么？二、STL的组成三、STL的使用四、STL之string五，STL之vector总结 前言 一、STL是什么？ STL（Standard Template Library），即标准模板库，是一个具有工业强度的，高效的C++程序库。可以理解TL是一些“容器”的集合，这些“容器”有list,vector,set,map等，STL也是算法和其他一些组件的集合。 其中STL这个"容器“‘里有很多头文件 包含以下13个 、、、、、、<memory.
C++ STL详解超全总结(快速入门STL)
热门推荐
行码棋
02-24 14万+
C++STL合集，包含vector，stack，queue，map，set，array，tuple，deque，priority_queue等诸多内容，全文上万字。
C++ STL之vector详解
行码棋
01-04 6万+
本文介绍了STL的vector的常用操作以及相关的注意事项
effective stl
12-14
《Effective STL》是一本关于标准模板库（STL）实践指南的书籍，旨在帮助开发者更好地理解和使用STL，提升代码的效率和可维护性。以下将详细解释书中的部分知识点。 1. 选择合适的容器：不同的容器有不同的特性和...
STL源码
08-03
**STL源码详解** STL（Standard Template Library，标准模板库）是C++编程语言中的一个重要组成部分，它提供了一组高效、灵活且可重用的容器、迭代器、算法和函数对象。STL的核心思想是泛型编程，即通过模板实现对...
STL格式模型文件整理
08-09
STL格式模型文件STL格式模型文件STL格式模型文件STL格式模型文件STL格式模型文件STL格式模型文件STL格式模型文件STL格式模型文件STL格式模型文件STL格式模型文件STL格式模型文件STL格式模型文件STL格式模型文件STL...
C++ 多态
最新发布
wxk2227814847的博客
07-10 498
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
鸿蒙开发：Universal Keystore Kit（密钥管理服务）【明文导入密钥(C/C++)】
m0_70748845的博客
07-07 397
以明文导入ECC密钥为例。具体的场景介绍及支持的算法规格。
C语言-动态内存管理
m0_73605503的博客
07-07 1054
在C语言编程中，动态内存管理是一个至关重要的概念。它不仅涉及到程序如何高效地使用内存资源，还影响到程序的稳定性和性能。通过动态分配内存，程序可以根据运行时的需求灵活地调整内存使用，这对于处理不确定的数据量和实现高效的资源利用尤为重要。在这篇文章中，我们将深入探讨C语言中的动态内存管理机制，了解如何使用标准库函数如 malloc、calloc、realloc 和 free，并讨论一些常见的内存管理陷阱和最佳实践。
C++初探究（2）
Frenemy__的博客
07-09 1264
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
【C++】include头文件中双引号和尖括号的区别
qq_35902025的博客
07-10 167
总结来说，最佳实践是使用尖括号来包含标准库的头文件，以确保代码的可移植性和避免潜在的命名冲突。对于项目特定的头文件，使用双引号可以提供更多的灵活性，但需要确保包含路径的正确性。使用双引号时，如果当前目录或子目录中存在与标准库同名的文件，它将被优先包含，这可能会导致意外地覆盖标准库文件。使用双引号 " " 时，编译器首先会在当前文件所在的目录搜索头文件，如果找不到，然后才会在系统的目录中搜索。这些目录通常包含了编译器自带的库文件。使用双引号时，如果头文件的位置发生变化，可能需要修改代码中的包含路径。
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 936
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
【C++】类和对象--类，实例化，this指针
tidal_wave的博客
07-10 608
前面的几篇文章我们介绍了命名空间，inline，nullptr等C++中常见的的基础概念。今天的文章我们来介绍一些C++中类与对象的内容。在现实世界中，经常有属于同一类的对象。例如，你的自行车只是世界上很多自行车中的一辆。在面向对象软件中，也有很多共享相同特征的不同的对象：矩形、雇用记录、视频剪辑等。可以利用这些对象的相同特征为它们建立一个集合。而这个集合就称为类。类是定义同一类所有对象的变量和方法的蓝图或原型。
C语言 do while 循环语句练习 中
2401_84378523的博客
07-05 606
注：使用Sleep首字母必须大写，引用头函数#include <windows.h>，Sleep是延时函数，用来做延时效果。使用system需应用头函数。
C语言有哪些特点？
YesPMP平台
07-10 144
在用C语言实现相同功能时的代码基本一致，不需或仅需进行少量改动便可完成移植，这就意味着，对于一台计算机编写的C程序可以在另一台计算机上轻松地运行，从而极大的减少了程序移植的工作强度。，它有着清晰的层次，可按照模块的方式对程序进行编写，十分有利于程序的调试，且c语言的处理和表现能力都非常的强大，依靠非常全面的。C语言是面向过程的编程语言，用户只需要关注所被解决问题的本身，而不需要花费过多的精力去了解相关硬件，且针对不同的。所具有的良好特性，又包含了许多低级语言的优势，故在系统软件编程领域有着广泛的应用。
[c++] 可变参数模版
l23456789mmmmm的博客
07-07 482
可变参数模板是C++11及之后才开始使用,学校的老古董编译器不一定能用相信大家在刚入门c/c++时都接触过printf函数printf用于将数据格式化输出到屏幕上,它的参数非常有意思,可以支持任意数量,任意类型的多参数.而如果我们想实现类似这种的传参,在C里似乎并不支持c++11提出了可变模板参数来解决这一问题。
STL专题.docx
12-04
"STL专题介绍，包括sort函数的使用示例" STL（Standard Template Library，标准模板库）是C++编程语言中一个强大的工具集合，它包含了一系列高效、可复用的数据结构和算法。在给定的文档中，主要讨论了STL中的`sort...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值