C++学习下

模版

模版的概念

模版就是建立通用的模具，大大提高复用性

模板的特点：

• 模板不可以直接使用，它只是一个框架
• 模板的通用不是万能的

函数模板

• C++另一种编程思想成为泛型编程，主要利用的技术就是模板
• C++提供两种模板机制：函数模板和类模板

函数模板语法

函数模板的作用：

建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表

语法：

template<typename T>
函数声明或定义

• template 声明创建模板
• typename 声明其后的符号是一中数据类型，可以用class代替
• T 通用数据类型，名称可以替换，通常为大写字母

#include<iostream>

using namespace std;

//声明一个模板，告诉编译器后面代码中紧跟着的T不要报错，T是一个通用数据类型 
template<typename T>
void mySwap(T &a, T &b){
	T temp = a;
	a = b;
	b = temp;
}

void test1(){
	int a = 10;
	int b = 20;
	
	//两种方式来使用模板
	//1.自动类型推导
	mySwap(a, b);
	cout << a << " " << b << endl; 
	
	//2.显示指定类型
	mySwap<int>(a, b);
	cout << a << " " << b << endl; 
}

int main(){
	test1();
	return 0;
}

模板注意事项

• 自动类型推导，必须推导出一致的数据类型T，才可以使用
• 模板必须要确定出T的数据类型，才可以使用

普通函数与函数模板的区别

• 普通函数调用时可以发生自动类型转换（隐式类型转换）
• 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
• 如果利用显示指定类型的方法，可以发生隐式类型转换

普通函数与函数模板的调用规则

1. 如果函数模板和普通函数都可以实现，优先调用普通函数
2. 可以通过空模板参数列表来强调调用函数模板
3. 函数模板可以发生重载
4. 如果函数模板可以产生更好的匹配，优先调用函数模板

#include<iostream>

using namespace std;

void myPrint(int a, int b){
	cout << "调用的普通函数" << endl; 
}

template<class T>
void myPrint(T a, T b){
	cout << "调用的函数模板" << endl; 
}

void test1(){
	int a = 10;
	int b = 20;
	//通过空模板参数列表，强制调用函数模板
	myPrint<>(a,b); 
	
	//如果函数模板可以产生更好的匹配，优先调用函数模板
	char a = 'a';
	char b = 'b';
	myPrint(a,b); 
}

int main(){
	test1();
	return 0;
}

既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性

模板的局限性

• 模板的通用性不是万能的，有些特定数据类型，需要用具体化方式做特殊实现

template<class T>
    void f(T a, T b){
    a = b;
}

在上述代码中，如果传入的a和b是一个数组，就无法实现了

//特殊数据类型进行具体化重写
template<>
void temp(person &a, person b){
    
}

类模板

类模板基本语法

类模板作用：

建立一个通用类，类中的成员数据类型可以不具体指定，用一个虚拟的类型来代表。

语法：

template<typename T>
类

template<class NameType, class AgeType>
class person{
    public:
    NameType m_name;
    AgeType m_age;
}

void test1(){
    person<string, int> p("张三", 90);
}

类模板与函数模板区别

1. 类模板没有自动类型推导的使用方式
2. 类模板在模板列表中可以有默认参数

template<class NameType, class AgeType = int>
class person{
    public:
    NameType m_name;
    AgeType m_age;
}

void test1(){
    person<string> p("张三", 90);
}

类模板中成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有区别的：

• 普通类中的成员函数一开始就可以创建
• 类模板中的成员函数在调用时才创建

类模板对象做函数参数

类模板实例化出的对象，向函数传参的方式

一共有三种传入方式：

1. 指定传入的类型

   直接显示对象的数据类型

2. 参数模板化

   将对象中的参数变为模板进行传递

3. 整个类模板化

   将这个对象类型模板化进行传递

#include<iostream>
#include<string>

using namespace std;

template<class T1, class T2>
class person{
	public:
		T1 m_name;
		T2 m_age;
		
		person(T1 name, T2 age){
			this->m_age = age;
			this->m_name = name;
		}
		
		void showPerson(){
			cout << this->m_name << " " << this->m_age << endl;
		}
};

//指定传入类型 
void printPerson1(person<string, int> &p){
	p.showPerson();
}

//参数模板化
template<class T1, class T2>
void printPerson2(person<T1, T2>&p){
	p.showPerson();
}

//整个类模板化
template<class T>
void printPerson3(T &p){
	p.showPerson();
} 

void test1(){
	person<string, int>p("张三", 18);
	printPerson3(p);
}

int main(){
	test1();
	return 0;
}

类模板与继承

当类模板碰到继承时，需要注意以下几点：

• 当子类继承的父类是一个类模板时，子类在声明的时候，需要指定父类中T的类型
• 如果不指定，编译器无法给子列分配内存
• 如果想灵活指定出父类中T的类型，子类也需要变为类模板

#include<iostream>

using namespace std;

template<class T>
class Base{
	public:
		T m;
};

class Son : public Base<int>{
	
};

template<class T1, class T2>
class Son1 : public Base<T2>{
	public:
		T1 obj;
};

void test1(){
	Son1<int, char>S2;
}

int main(){
	test1();
	return 0;
}

类模板成员函数类外实现

#include<iostream>
#include<string>

using namespace std;

template<class T1, class T2>
class Person{
	public:
		T1 m_name;
		T2 m_age;
		
		Person(T1 name, T2 age);
		
		void showPerson();
};

//构造函数的类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age){
		this->m_name = name;
		this->m_age = age;
} 

//成员函数的类外实现
template<class T1, class T2>
void Person<T1,T2>::showPerson(){
	cout << this->m_name << " " << this->m_age << endl;
}


int main(){
	test1();
	return 0;
}

类模板分文件编写

问题：

• 类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决：

• 直接包含.cpp源文件
• 将声明和实现写到同一个文件，并更改为.hpp，hpp是约定的名称，不是强制的

类模板和友元

• 全局函数类内实现

  直接在类内声明友元即可

• 全局函数类外实现

  需要提前让编译器知道全局函数的存在

#include<string>

using namespace std;

//提前让编译器知道person存在 
template<class T1, class T2>
class Person; 

//提前让编译器知道类外实现的函数 
template<class T1, class T2>
void printPerson1(Person<T1, T2> p){
	cout << p.m_name << " " << p.m_age << endl;
}

template<class T1, class T2>
class Person{
	
	//全局函数类内实现
	friend void printPerson(Person<T1, T2> p){
		cout << p.m_name << " " << p.m_age << endl;
	}  
	
	//全局函数类外实现
	//如果全局函数是类外实现的话，需要让编译器提前实现 
	friend void printPerson1<>(Person<T1, T2> p); 
	
	public:
		Person(T1 name, T2 age){
			this->m_name = name;
			this->m_age = age;
		}
		
	private:
		T1 m_name;
		T2 m_age;
};



void test1(){
	Person<string, int>p("Tom", 18);
	printPerson1(p);
}

int main(){
	test1();
	return 0;
}

STL初始

STL的诞生

• 长久以来，软件界一直希望建立一种可重复利用的东西
• C++的面向对象和泛型编程思想，目的就是复用性的提升
• 大多情况下，数据结构和算法都未能有一套标准，导致被迫从事大量重复工作
• 为了建立数据结构和算法的一套标准，诞生了STL

STL基本概念

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

STL六大组件

STL大体分为六大组件：

1. 容器

   各种数据结构，如vector、list等用来存放数据

2. 算法

   各种常用算法，如sort、find等

3. 迭代器

   扮演了容器与算法之间的胶合剂

4. 仿函数

   行为类似函数，可作为算法的某种策略

5. 适配器（配接器）

   一种用来修饰容器或者仿函数或迭代器接口的东西

6. 空间配置器

   负责空间的配置与管理

STL中容器、算法、迭代器

容器：置物之所也

STL容器就是将运用最广泛的一些数据结构实现出来

常用的数据结构：数组、链表、树、栈、队列、集合、映射表等

这些容器分为序列式容器和关联式容器两种：

• 序列式容器

  强调值的排序，序列式容器中的每个元素均有固定的位置

• 关联式容器

  二叉树结构，各元素之间没有严格的物理上的顺序关系

算法：问题之解法也

有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(algorithms)

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

• 质变算法

  是指运算过程中会更改区间的元素的内容。例如拷贝、替换、删除等

• 非质变算法

  是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极限等

迭代器：容器和算法之间粘合剂

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

每个容器都有自己专属的迭代器

迭代器使用非常类似于指针

迭代器种类：

种类	功能	支持运算
输入迭代器	对数据的只读访问	只读，支持++、==、！=
输出迭代器	对数据的只写访问	只读，支持++
前向迭代器	读写操作，并够向前推进迭代器	读写，支持++、==、！=
双向迭代器	读写操作，并能够向前和向后操作	读写，支持++、--
随机访问迭代器	读写操作，可以以跳跃的方式访问任意数据，功能最强的迭代器	读写，支持++、--、[n]、-n、<、<=、>、>=

常用的容器中迭代器的种类为双向迭代器和随机访问迭代器

容器算法迭代器初始

vector存放内置数据类型

容器：vector

算法：for_each

迭代器：vector::iterator

#include<iostream>
#include<vector>
#include<algorithm>//标准算法头文件 

using namespace std;

void myPrint(int val){
	cout << val << endl;
}

void test1(){
	//创建了一个vector容器，数组 
	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();  //结束迭代器，指向容器中最后一个元素的下一个位置
	
	//第一种遍历方法
	while(itBegin != itEnd){
		cout << *itBegin << endl;
		itBegin++;
	} 
	
	//第二种遍历方式
	for(vector<int>::iterator it = v.begin(); it != v.end(); it++){
		cout << *it << endl;
	} 
	
	//第三种遍历方式 利用STL提供遍历算法
	 for_each(v.begin(), v.end(), myPrint);	 
}

int main(){
	test1();
	return 0;
}

vector存放自定义数据类型

#include<iostream>
#include<vector>
#include<algorithm>//标准算法头文件 
#include<string>

using namespace std;

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

void test1(){
	vector<Person> v;
	
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);
	Person p5("eee", 50);
	
	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);
	v.push_back(p5);
	
	//遍历容器中的数据
	for(vector<Person>::iterator it = v.begin(); it != v.end(); it++){
        //也可以是it->m_name
		cout << "姓名：" << (*it).m_name << " " << "年龄：" << (*it).m_age << endl; 
	} 
	
}

int main(){
	test1();
	return 0;
}

容器嵌套容器

#include<iostream>
#include<vector>
#include<algorithm>//标准算法头文件 
#include<string>

using namespace std;

void test1(){
	vector<vector<int>> v;
	
	//创建小容器
	vector<int> v1;
	vector<int> v2;
	vector<int> v3;
	vector<int> v4;
	
	for(int i = 0; i < 4; i++){
		v1.push_back(i + 1);
		v2.push_back(i + 2);
		v3.push_back(i + 3);
		v4.push_back(i + 4);
	}
	
	v.push_back(v1);
	v.push_back(v2);
	v.push_back(v3);
	v.push_back(v4);
	
	//通过大容器，把所有都遍历一遍
	for(vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++){
		for(vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++){
			cout << (*vit) << endl;
		}
	} 
	 
}

int main(){
	test1();
	return 0;
}

STL常用容器

string容器

string基本概念

本质：

• string是C++风格的字符串，而string本质上是一个类

string 与char *区别：

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

特点：

• string类内封装了很多成员方法
• string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责

string构造函数

构造函数原型：

• string() //创建一个空的字符串

• string(const char*s) //使用字符串初始化

• string(const string& str) //使用一个string 对象初始化另一个string对象

• string(int n, char c) //使用n个字符c初始化

#include<iostream>
#include<string>

using namespace std;

int main(){
	string s1;
	const char * str = "helloworld";
	string s2(str);
	strings3(s2);
	string(10, 'a');
	
	return 0;
}

string复制赋值操作

功能：给string字符串进行赋值

复制的函数原型：

• string& operator=(const char* s) //把char*类型字符串赋值给当前字符串
• string& operator=(const string& s) //把字符串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赋值给当前字符串

#include<iostream>
#include<string>

using namespace std;

int main(){
	string s1 = "helloworld";
	string s2 = s1;
	string s3 = 'a';
	string s4;
	s4.assign("helloworld");
	string s5;
	s5.assign("helloworld", 5);
	string s6;
	s6.assign(s5);
	string s7;
	s7.assign('a', 6);
	
	return 0;
}

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); //同operator+=(const string& str)
• string& append(const string &s, int pos, int n);//字符串s中从pos开始的n个字符连接到字符串结尾

字符串查找和替换

功能描述：

• 查找：查找指定字符串是否存在
• 替换：在指定的位置替换字符串

函数原型：

• 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个字符为字符串s

总结：

• find查找是从左往后，rfind从右往左
• find找到字符串后返回查找的第一个字符位置，找不到返回-1
• replace在替换时，要指定从哪个位置起，多少个字符，替换成什么样的字符串

字符串比较

能描述：

• 字符串之间的比较

比较方式：

• 字符串比较是按字符的ASCII码进行对比

= 返回 0

> 返回 1

< 返回 -1

函数原型：

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

总结：字符串对比主要是用于比较两个字符串是否相等，判断谁大谁小的意义并不是很大

字符串存取

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

• char& operator[](int n); //通过[]方式取字符
• char& at(int n); //通过at方法获取字符

string插入和删除

功能描述：

• 对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个字符

string子串获取

功能描述：

• 从字符串中获取想要的子串

函数原型：

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

vector容器

vector基本概念

功能：

• vector数据结构和数组非常相似，也称为单端数组

vector与普通数组的区别：

• 不同之处在于数组是静态的，而vector可以动态拓展

动态拓展：

• 并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间
• vector容器的迭代器是支持随机访问的迭代器

vector构造函数

功能描述：

• 创建vector容器

函数原型：

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

vector赋值操作

功能描述：

• 给vector容器进行赋值

函数原型：

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

vector容量和大小

功能描述：

• 对vector容器的容量和大小操作

函数原型：

• empty(); //判断容器是否为空

• capacity(); //容器的容量

• size(); //返回容器中元素的个数

• resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。

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

• resize(int num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。

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

vector插入和删除

功能描述：

• 对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(); //删除容器中所有元素

vector数据存取

功能描述：

• 对vector中的数据的存取操作

函数原型：

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

vector互换容器

功能描述：

• 实现两个容器内元素进行互换

函数原型：

• swap(vec); // 将vec与本身的元素互换

总结：

• swap可以使两个容器互换，可以达到实用的收缩内存效果

vector预留空间

功能描述：

• 减少vector在动态扩展容量时的扩展次数

函数原型：

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

deque容器

deque容器基本概念

功能：

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

deque与vector区别：

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

deque内部工作原理：

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

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

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

deque构造函数

功能描述：

• deque容器构造

函数原型：

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

deque赋值操作

功能描述：

• 给deque容器进行赋值

函数原型：

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

deque大小操作

功能描述：

• 对deque容器的大小进行操作

函数原型：

• deque.empty(); //判断容器是否为空

• deque.size(); //返回容器中元素的个数

• deque.resize(num); //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。

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

• deque.resize(num, elem); //重新指定容器的长度为num,若容器变长，则以elem值填充新位置。

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

deque插入和删除

功能描述：

• 向deque容器中插入和删除数据

函数原型：

两端插入操作：

• push_back(elem); //在容器尾部添加一个数据
• push_front(elem); //在容器头部插入一个数据
• pop_back(); //删除容器最后一个数据
• 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位置的数据，返回下一个数据的位置。

deque数据存取

功能描述：

• 对deque 中的数据的存取操作

函数原型：

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

deque排序

功能描述：

• 利用算法实现对deque容器进行排序

算法：

• sort(iterator beg, iterator end) //对beg和end区间内元素进行排序

总结：

sort算法非常实用，使用时包含头文件 algorithm即可

stack容器

概念：

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

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

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

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

stack常用接口

功能描述：栈容器常用的对外接口

构造函数：

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

赋值操作：

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

数据存取：

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

大小操作：

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

queue容器

概念：队列是一种先进先出的数据结构，它有两个出口

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

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

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

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

queue容器常用接口

功能描述：栈容器常用的对外接口

构造函数：

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

赋值操作：

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

数据存取：

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

大小操作：

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

list容器

list容器基本概念

功能：

将数据进行链式存储

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

链表的组成：

链表有一系列结点组成

结点的组成

一个是存储单元的数据域，另一个是存储下一个结点地址的指针域

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

list的优点：

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

list的缺点：

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

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

list构造函数

功能描述：

• 创建list容器

函数原型：

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

list赋值和交换

功能描述：

• 给list容器进行赋值，以及交换list容器

函数原型：

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

list大小操作

功能描述：

• 对list容器的大小进行操作

函数原型：

• size(); //返回容器中元素的个数

• empty(); //判断容器是否为空

• resize(num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。

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

• resize(num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。

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

list插入和删除

功能描述：

• 对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反转和排序

功能描述：

• 将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

• 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 val1 , int val2)
  {
  	return val1 > val2;
  }
  
  //反转和排序
  void test01()
  {
  	list<int> L;
  	L.push_back(90);
  	L.push_back(30);
  	L.push_back(20);
  	L.push_back(70);
  	printList(L);
  
  	//反转容器的元素
  	L.reverse();
  	printList(L);
  
  	//排序
  	L.sort(); //默认的排序规则 从小到大
  	printList(L);
  
  	L.sort(myCompare); //指定规则，从大到小
  	printList(L);
  }
  
  int main() {
  
  	test01();
  
  	system("pause");
  
  	return 0;
  }
  

• 对于自定义数据类型，必须要指定排序规则，否则编译器不知道如何进行排序

• 高级排序只是在排序规则上再进行一次逻辑规则制定，并不复杂

set/multiset容器

set基本概念

简介：

• 所有元素都会在插入时自动被排序

本质：

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

set和multiset区别：

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

set构造和赋值

功能描述：创建set容器以及赋值

构造：

• set<T> st; //默认构造函数：
• set(const set &st); //拷贝构造函数

赋值：

• set& operator=(const set &st); //重载等号操作符

• set容器插入数据时用insert

• set容器插入数据的数据会自动排序

set的大小和交换

功能描述：

• 统计set容器大小以及交换set容器

函数原型：

• size(); //返回容器中元素的数目
• empty(); //判断容器是否为空
• swap(st); //交换两个集合容器

set插入和删除

功能描述：

• set容器进行插入数据和删除数据

函数原型：

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

set查找和统计

功能描述：

• 对set容器进行查找数据以及统计数据

函数原型：

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

set和multiset区别

学习目标：

• 掌握set和multiset的区别

区别：

• set不可以插入重复数据，而multiset可以

• set插入数据的同时会返回插入结果，表示插入是否成功

• multiset不会检测数据，因此可以插入重复数据

• 如果不允许插入重复数据可以利用set

• 如果需要插入重复数据利用multiset

#include <set>

//set和multiset区别
void test01()
{
	set<int> s;
    //插入结果
	pair<set<int>::iterator, bool>  ret = s.insert(10);
	if (ret.second) {
		cout << "第一次插入成功!" << endl;
	}
	else {
		cout << "第一次插入失败!" << endl;
	}

	ret = s.insert(10);
	if (ret.second) {
		cout << "第二次插入成功!" << endl;
	}
	else {
		cout << "第二次插入失败!" << endl;
	}
    
	//multiset
	multiset<int> ms;
	ms.insert(10);
	ms.insert(10);

	for (multiset<int>::iterator it = ms.begin(); it != ms.end(); it++) {
		cout << *it << " ";
	}
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

pair对组创建

功能描述：

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

两种创建方式：

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

set容器排序

学习目标：

• set容器默认排序规则为从小到大，掌握如何改变排序规则

主要技术点：

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

1. set存放内置数据类型

   #include<iostream>
   #include<set>
   
   using namespace std;
   
   class MyCompare{
   	public:
       //重载()
   		bool operator()(int v1, int v2){
   			return v1 > v2;
   		}
   };
   
   void test1(){
   	set<int> s1;
   	
   	s1.insert(10);
   	s1.insert(20);
   	s1.insert(30);
   	s1.insert(40);
   	s1.insert(50);
   	s1.insert(60);
   	
   	for(set<int>::iterator it = s1.begin(); it != s1.end(); it++){
   		cout << (*it) << endl;
   	}
   	
   	//指定排序规则为从大到小
   	set<int, MyCompare>s2;
   	s2.insert(10);
   	s2.insert(20);
   	s2.insert(30);
   	s2.insert(40);
   	s2.insert(50);
   	s2.insert(60);
   	for(set<int>::iterator it = s2.begin(); it != s2.end(); it++){
   		cout << (*it) << endl;
   	}
   }
   
   int main(){
   	test1();
   	
   	return 0;
   }
   

2. set存放自定义数据类型

   #include<iostream>
   #include<set>
   #include<string>
   
   using namespace std;
   
   class Person{
   	public:
   		string m_name;
   		int m_age;
   		
   		Person(string name, int age){
   			this->m_name = name;
   			this->m_age = age;
   		}
   		
   };
   
   class MyCompare{
   	public:
   		//重载() 
   		bool operator()(const Person& v1,const Person& v2){
   			return v1.m_age < v2.m_age;
   		}
   };
   
   void test1(){
   	//自定义的类型都会指定排序规则 
   	set<Person, MyCompare> s1;
   	
   	Person p1("aaa", 10);
   	Person p2("bbb", 20);
   	Person p3("ccc", 30);
   	Person p4("ddd", 40);
   	Person p5("eee", 50);
   	Person p6("fff", 60);
   	
   	s1.insert(p1);
   	s1.insert(p2);
   	s1.insert(p3);
   	s1.insert(p4);
   	s1.insert(p5);
   	s1.insert(p6);
   	
   	for(set<Person>::iterator it = s1.begin(); it != s1.end(); it++){
   		cout << it->m_name << " " << it->m_age << endl;
   	}
   	
   
   }
   
   int main(){
   	test1();
   	
   	return 0;
   }
   

map/multimap容器

map基本概念

简介：

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

本质：

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

优点：

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

map和multimap区别：

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

map构造和赋值

功能描述：

• 对map容器进行构造和赋值操作

函数原型：

构造：

• map<T1, T2> mp; //map默认构造函数:
• map(const map &mp); //拷贝构造函数

赋值：

• map& operator=(const map &mp); //重载等号操作符

#include <map>

void printMap(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;
}

void test01()
{
	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));
	printMap(m);

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

	map<int, int>m3;
	m3 = m2; //赋值
	printMap(m3);
}

int main() {

	test01();

	system("pause");

	return 0;
}

map大小和交换

功能描述：

• 统计map容器大小以及交换map容器

函数原型：

• size(); //返回容器中元素的数目
• empty(); //判断容器是否为空
• swap(st); //交换两个集合容器

map插入和删除

功能描述：

• map容器进行插入数据和删除数据

函数原型：

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

#include <map>

void printMap(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;
}

void test01()
{
	//插入
	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);
}

int main() {

	test01();

	system("pause");

	return 0;
}

map查找和统计

功能描述：

• 对map容器进行查找数据以及统计数据

函数原型：

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

map容器排序

学习目标：

• 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容器

STL函数对象

函数对象

函数对象概念

概念：

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

本质：

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

函数对象的使用

特点：

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

谓词

谓词概念

概念：

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

内建函数对象

内建函数对象意义

概念：

• STL内建了一些函数对象

分类：

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

用法：

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

算术仿函数

功能描述：

• 实现四则运算
• 其中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> //取反仿函数

关系仿函数

功能描述：

• 实现关系对比

仿函数原型：

• 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> //小于等于

逻辑仿函数

功能描述：

• 实现逻辑运算

函数原型：

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

STL常用算法

概述：

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

常用遍历算法

学习目标：

• 掌握常用的遍历算法

算法简介：

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

for_each算法

功能描述：

• 实现遍历容器

函数原型：

• for_each(iterator beg, iterator end, _func);

  // 遍历算法 遍历容器元素

  // beg 开始迭代器

  // end 结束迭代器

  // _func 函数或者函数对象

#include <algorithm>
#include <vector>

//普通函数
void print01(int val) 
{
	cout << val << " ";
}
//函数对象
class print02 
{
 public:
	void operator()(int val) 
	{
		cout << val << " ";
	}
};

//for_each算法基本用法
void test01() {

	vector<int> v;
	for (int i = 0; i < 10; i++) 
	{
		v.push_back(i);
	}

	//遍历算法
	for_each(v.begin(), v.end(), print01);
	cout << endl;

	for_each(v.begin(), v.end(), print02());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

transform算法

功能描述：

• 搬运容器到另一个容器中

函数原型：

• transform(iterator beg1, iterator end1, iterator beg2, _func);

//beg1 源容器开始迭代器

//end1 源容器结束迭代器

//beg2 目标容器开始迭代器

//_func 函数或者函数对象，在搬运过程中进行一些数据处理

#include<vector>
#include<algorithm>

//常用遍历算法  搬运 transform

class TransForm
{
public:
	int operator()(int val)
	{
		return val;
	}

};

class MyPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int>v;
	for (int i = 0; i < 10; i++)
	{
		v.push_back(i);
	}

	vector<int>vTarget; //目标容器

	vTarget.resize(v.size()); // 目标容器需要提前开辟空间

	transform(v.begin(), v.end(), vTarget.begin(), TransForm());

	for_each(vTarget.begin(), vTarget.end(), MyPrint());
}

int main() {

	test01();

	system("pause");

	return 0;
}

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

常用查找算法

学习目标：

• 掌握常用的查找算法

算法简介：

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

find算法

功能描述：

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

函数原型：

• find(iterator beg, iterator end, value);

  // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

  // beg 开始迭代器

  // end 结束迭代器

  // value 查找的元素

#include <algorithm>
#include <vector>
#include <string>
void test01() {

	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i + 1);
	}
	//查找容器中是否有 5 这个元素
	vector<int>::iterator it = find(v.begin(), v.end(), 5);
	if (it == v.end()) 
	{
		cout << "没有找到!" << endl;
	}
	else 
	{
		cout << "找到:" << *it << 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;
		}
		return false;
	}

public:
	string m_Name;
	int m_Age;
};

void test02() {

	vector<Person> v;

	//创建数据
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	vector<Person>::iterator it = find(v.begin(), v.end(), p2);
	if (it == v.end()) 
	{
		cout << "没有找到!" << endl;
	}
	else 
	{
		cout << "找到姓名:" << it->m_Name << " 年龄: " << it->m_Age << endl;
	}
}

find_if算法

功能描述：

• 按条件查找元素

函数原型：

• find_if(iterator beg, iterator end, _Pred);

  // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

  // beg 开始迭代器

  // end 结束迭代器

  // _Pred 函数或者谓词（返回bool类型的仿函数）

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

//内置数据类型
class GreaterFive
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
};

void test01() {

	vector<int> v;
	for (int i = 0; i < 10; i++) {
		v.push_back(i + 1);
	}

	vector<int>::iterator it = find_if(v.begin(), v.end(), GreaterFive());
	if (it == v.end()) {
		cout << "没有找到!" << endl;
	}
	else {
		cout << "找到大于5的数字:" << *it << endl;
	}
}

//自定义数据类型
class Person {
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
public:
	string m_Name;
	int m_Age;
};

class Greater20
{
public:
	bool operator()(Person &p)
	{
		return p.m_Age > 20;
	}

};

void test02() {

	vector<Person> v;

	//创建数据
	Person p1("aaa", 10);
	Person p2("bbb", 20);
	Person p3("ccc", 30);
	Person p4("ddd", 40);

	v.push_back(p1);
	v.push_back(p2);
	v.push_back(p3);
	v.push_back(p4);

	vector<Person>::iterator it = find_if(v.begin(), v.end(), Greater20());
	if (it == v.end())
	{
		cout << "没有找到!" << endl;
	}
	else
	{
		cout << "找到姓名:" << it->m_Name << " 年龄: " << it->m_Age << endl;
	}
}

int main() {

	//test01();

	test02();

	system("pause");

	return 0;
}

adjacent_find算法

功能描述：

• 查找相邻重复元素

函数原型：

• adjacent_find(iterator beg, iterator end);

  // 查找相邻重复元素,返回相邻元素的第一个位置的迭代器

  // beg 开始迭代器

  // end 结束迭代器

binary_search算法

功能描述：

• 查找指定元素是否存在

函数原型：

• bool binary_search(iterator beg, iterator end, value);

  // 查找指定的元素，查到 返回true 否则false

  // 注意: 在无序序列中不可用

  // beg 开始迭代器

  // end 结束迭代器

  // value 查找的元素

总结：

二分查找法查找效率很高，值得注意的是查找的容器中元素必须的有序序列

count算法

功能描述：

• 统计元素个数

函数原型：

• count(iterator beg, iterator end, value);

  // 统计元素出现次数

  // beg 开始迭代器

  // end 结束迭代器

  // value 统计的元素

count_if算法

功能描述：

• 按条件统计元素个数

函数原型：

• count_if(iterator beg, iterator end, _Pred);

  // 按条件统计元素出现次数

  // beg 开始迭代器

  // end 结束迭代器

  // _Pred 谓词

常见排序算法

学习目标：

• 掌握常用的排序算法

算法简介：

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

sort算法

功能描述：

• 对容器内元素进行排序

函数原型：

• sort(iterator beg, iterator end, _Pred);

  // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

  // beg 开始迭代器

  // end 结束迭代器

  // _Pred 谓词

random_shuffle算法

功能描述：

• 洗牌 指定范围内的元素随机调整次序

函数原型：

• random_shuffle(iterator beg, iterator end);

  // 指定范围内的元素随机调整次序

  // beg 开始迭代器

  // end 结束迭代器

总结：

random_shuffle洗牌算法比较实用，使用时记得加随机数种子

#include <algorithm>
#include <vector>
#include <ctime>

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	srand((unsigned int)time(NULL));
	vector<int> v;
	for(int i = 0 ; i < 10;i++)
	{
		v.push_back(i);
	}
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;

	//打乱顺序
	random_shuffle(v.begin(), v.end());
	for_each(v.begin(), v.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

merge算法

功能描述：

• 两个容器元素合并，并存储到另一容器中

函数原型：

• merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

  // 容器元素合并，并存储到另一容器中

  // 注意: 两个容器必须是有序的

  // beg1 容器1开始迭代器
  // end1 容器1结束迭代器
  // beg2 容器2开始迭代器
  // end2 容器2结束迭代器
  // dest 目标容器开始迭代器

reverse算法

功能描述：

• 将容器内元素进行反转

函数原型：

• reverse(iterator beg, iterator end);

  // 反转指定范围的元素

  // beg 开始迭代器

  // end 结束迭代器

常用拷贝和替换算法

学习目标：

• 掌握常用的拷贝和替换算法

算法简介：

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

copy算法

功能描述：

• 容器内指定范围的元素拷贝到另一容器中

函数原型：

• copy(iterator beg, iterator end, iterator dest);

  // 按值查找元素，找到返回指定位置迭代器，找不到返回结束迭代器位置

  // beg 开始迭代器

  // end 结束迭代器

  // dest 目标起始迭代器

总结：

利用copy算法在拷贝时，目标容器记得提前开辟空间

#include <algorithm>
#include <vector>

class myPrint
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};

void test01()
{
	vector<int> v1;
	for (int i = 0; i < 10; i++) {
		v1.push_back(i + 1);
	}
	vector<int> v2;
	v2.resize(v1.size());
	copy(v1.begin(), v1.end(), v2.begin());

	for_each(v2.begin(), v2.end(), myPrint());
	cout << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

replace算法

功能描述：

• 将容器内指定范围的旧元素修改为新元素

函数原型：

• replace(iterator beg, iterator end, oldvalue, newvalue);

  // 将区间内旧元素 替换成 新元素

  // beg 开始迭代器

  // end 结束迭代器

  // oldvalue 旧元素

  // newvalue 新元素

replace_if算法

功能描述:

• 将区间内满足条件的元素，替换成指定元素

函数原型：

• replace_if(iterator beg, iterator end, _pred, newvalue);

  // 按条件替换元素，满足条件的替换成指定元素

  // beg 开始迭代器

  // end 结束迭代器

  // _pred 谓词

  // newvalue 替换的新元素

swap算法

功能描述：

• 互换两个容器的元素

函数原型：

• swap(container c1, container c2);

  // 互换两个容器的元素

  // c1容器1

  // c2容器2

总结：

swap交换容器时，注意交换的容器要同种类型

常用算术生成算法

学习目标：

• 掌握常用的算术生成算法

注意：

• 算术生成算法属于小型算法，使用时包含的头文件为 #include <numeric>

算法简介：

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

accumulate算法

功能描述：

• 计算区间内 容器元素累计总和

函数原型：

• accumulate(iterator beg, iterator end, value);

  // 计算容器元素累计总和

  // beg 开始迭代器

  // end 结束迭代器

  // value 起始值

fill算法

功能描述：

• 向容器中填充指定的元素

函数原型：

• fill(iterator beg, iterator end, value);

  // 向容器中填充元素

  // beg 开始迭代器

  // end 结束迭代器

  // value 填充的值

常用集合算法

学习目标：

• 掌握常用的集合算法

算法简介：

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

set_intersection算法

功能描述：

• 求两个容器的交集

函数原型：

• set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

  // 求两个集合的交集

  // 注意:两个集合必须是有序序列

  // beg1 容器1开始迭代器
  // end1 容器1结束迭代器
  // beg2 容器2开始迭代器
  // end2 容器2结束迭代器
  // dest 目标容器开始迭代器

总结：

• 求交集的两个集合必须的有序序列
• 目标容器开辟空间需要从两个容器中取小值
• set_intersection返回值既是交集中最后一个元素的位置

set_union算法

功能描述：

• 求两个集合的并集

函数原型：

• set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

  // 求两个集合的并集

  // 注意:两个集合必须是有序序列

  // beg1 容器1开始迭代器
  // end1 容器1结束迭代器
  // beg2 容器2开始迭代器
  // end2 容器2结束迭代器
  // dest 目标容器开始迭代器

总结：

• 求并集的两个集合必须的有序序列
• 目标容器开辟空间需要两个容器相加
• set_union返回值既是并集中最后一个元素的位置

set_difference算法

功能描述：

• 求两个集合的差集

函数原型：

• set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

  // 求两个集合的差集

  // 注意:两个集合必须是有序序列

  // beg1 容器1开始迭代器
  // end1 容器1结束迭代器
  // beg2 容器2开始迭代器
  // end2 容器2结束迭代器
  // dest 目标容器开始迭代器

总结：

• 求差集的两个集合必须的有序序列
• 目标容器开辟空间需要从两个容器取较大值
• set_difference返回值既是差集中最后一个元素的位置