C++提高编程笔记

C++提高编程

本阶段主要针对C++泛型编程和 STL技术做详细讲解。

1 模板

1.1 模板的概念

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

模板特点：

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

1.2 函数模板

C++另一种编程思想称为：泛型编程，主要利用的技术就是模板

C++提供两种模板机制：函数模板 和 类模板

1.2.1 函数模板语法

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

语法：

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

解释：

template --- 声明创建模板

typename --- 表明其后面的符号是一种数据类型，可以用 class 代替

T --- 通用的数据类型，名称可以替换，通常为大写字母

示例：

//函数模板
template<typename T>
void mySwap(T &a, T &b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test01()
{
	int a = 10;
	int b = 20;
	//1、自动类型推导
	//mySwap(a, b);
	//2、显式指定类型
	mySwap<int>(a, b);
	cout << "a= " << a << endl;
	cout << "b= " << b << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

总结：

函数模板利用关键字 template
使用函数模板有两种方式：自动类型推导、显式指定类型
模板的目的是为了提高复用性，将类型参数化

1.2.2 函数模板注意事项

注意事项：

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

1.2.3 普通函数和函数模板的区别

普通函数和函数模板的区别：

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

示例：

//普通函数
int myAdd01(int a, int b)
{
	return a + b;
}
//函数模板
template<typename T>
T myAdd02(T a, T b)
{
	return a + b;
}

void test01()
{
	int a = 10;
	char c = 'c';
	
	cout << "a + c = " << myAdd01(a,c) << endl;
	
	cout<<"a + c = " << myAdd02<int>(a, c) << endl; 
}

int main()
{
	test01();

	system("pause");
	return 0;
}

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

调用规则如下：

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

示例：

//普通函数
void myPrint(int a, int b)
{
	cout << "调用普通函数" << endl;
}
//函数模板
template<typename T>
void myPrint(T a, T b)
{
	cout << "调用函数模板" << endl;
}

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

void test01()
{
	int a = 10;
	int b = 20;
	myPrint(a, b);

	//空模板参数列表 强制使用模板函数
	myPrint<>(a, b);
	 
	myPrint(a, b, 100);

	char c = 'a';
	char d = 'b';
	myPrint(c, d);
}

int main()
{
	test01();

	system("pause");
	return 0;
}

总结：既然提供了函数模板，就不要再提供普通函数，否则容易出现二义性。

1.2.5 模板的局限性

例如：

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

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

例如：

template<typename T>
void f(T a, T b)
{
    if(a > b)
    {
        ...
    }
}

在上述代码中，如果 T 的数据类型传入的是像 Person 这样的自定义数据类型，也无法正常运行

因此，C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

语法：

//函数模板
template<typename T>
bool myCompare(T &a, T &b)
{
	...
}

//具体化Person版本
template<> bool myCompare(Person &p1, Person &p2)
{
	...
}

示例：

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

	string m_Name;
	int m_Age;
};


//函数模板
template<typename T>
bool myCompare(T &a, T &b)
{
	return a == b;
}

//具体化Person版本
template<> bool myCompare(Person &p1, Person &p2)
{
	if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void test01()
{
	Person p1("Tom", 18);
	Person p2("Tom", 17);

	myCompare(p1, p1);
}

int main()
{
	test01();

	system("pause");
	return 0;
}

1.3 类模板

1.3.1 类模板语法

类模板作用：建立一个通用类，类中的成员数据类型可以不具体确定，用一个虚拟的类型来代表

语法：

template<typename T>
类

解释：

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

示例：

template<typename NameType, typename AgeType>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	void showInfo()
	{
		cout << "name= " << this->m_Name << " age= " << this->m_Age << endl;
	}

	NameType m_Name;
	AgeType m_Age;
};

void test01()
{
	Person<string, int> p1("Tom", 18);
	p1.showInfo();
}

int main()
{
	test01();

	system("pause");
	return 0;
}

1.3.2 类模板与函数模板区别

类模板与函数模板区别主要有两点：

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

示例：

template<typename NameType, typename AgeType = int>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	void showInfo()
	{
		cout << "name= " << this->m_Name << " age= " << this->m_Age << endl;
	}

	NameType m_Name;
	AgeType m_Age;
};

void test01()
{
	Person<string> p1("Tom", 18);
	p1.showInfo();
}

int main()
{
	test01();

	system("pause");
	return 0;
}

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

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

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

示例：

class Person1
{
public:
	void showPerson1()
	{
		cout << "Person1 show" << endl;
	}
};

class Person2
{
public:
	void showPerson2()
	{
		cout << "Person2 show" << endl;
	}
};

template<typename T>
class MyClass
{
public:
	T obj;

	void func1()
	{
		obj.showPerson1();
	}

	void func2()
	{
		obj.showPerson2();
	}
};

void test01()
{
	MyClass<Person1> m;
	m.func1();
	//m.func2();

}

int main()
{
	test01();

	system("pause");
	return 0;
}

1.3.4 类模板对象做函数参数

一共有三种传入方式：

指定传入的类型 --- 直接显示对象的数据类型

void printPerson1(Person<string, int> &p)
{
	p.showInfo();
}

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

template<typename T1, typename T2>
void printPerson2(Person<T1, T2> &p)
{
	p.showInfo();
}

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

template<typename T>
void printPerson3(T &p)
{
	p.showInfo();
	cout << "T的数据类型" << typeid(T).name() << endl;
}

示例：

template<typename T1, typename T2>
class Person
{
public:
	Person(T1 name, T2 age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	void showInfo()
	{
		cout << "name = " << m_Name << " age = " << this->m_Age << endl;
	}

	T1 m_Name;
	T2 m_Age;
};

//1、指定传入类型
void printPerson1(Person<string, int> &p)
{
	p.showInfo();
}

void test01()
{
	Person<string, int> p("孙悟空", 100);
	printPerson1(p);
}

//2、参数模板化
template<typename T1, typename T2>
void printPerson2(Person<T1, T2> &p)
{
	p.showInfo();
}

void test02()
{
	Person<string, int> p("猪八戒", 90);
	printPerson2(p);
}

//3、整个类模板化
template<typename T>
void printPerson3(T &p)
{
	p.showInfo();
	cout << "T的数据类型" << typeid(T).name() << endl;
}
void test03()
{
	Person<string, int> p("唐僧", 80);
	printPerson3(p);
}

int main()
{
	test01();
	test02();
	test03();

	system("pause");
	return 0;
}

1.3.5 类模板与继承

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

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

示例：

template<typename T>
class Base
{
	T m;
};

//子类在声明的时候，要指定出父类中T的类型
class Son :public Base<int>
{

};

//如果想灵活指定父类中的T，子类也变为类模板
template<typename T1, typename T2>
class Son2 :public Base<T2>
{
	T1 obj;
};

void test01()
{
	Son2<int, char> s;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

1.3.6 类模板成员函数类外实现

示例：

template<typename T1, typename T2>
class Person
{
public:
	Person(T1 name, T2 age);

	void showPerson();

	T1 m_Name;
	T2 m_Age;
};

template<typename T1, typename T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_Name = name;
	this->m_Age = age;
}

template<typename T1, typename T2>
void Person<T1, T2>::showPerson()
{
	cout << "name= " << this->m_Name << " age= " << this->m_Age << endl;
}



void test01()
{
	Person<string, int> p("Tom", 18);
	p.showPerson();
}

int main()
{
	test01();

	system("pause");
	return 0;
}

1.3.7 类模板分文件编写

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

两个解决方案：

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

示例：

Person.hpp文件

#pragma once
#include <iostream>
using namespace std;

template<typename T1, typename T2>
class Person
{
public:
	Person(T1 name, T2 age);

	void showPerson();

	T1 m_Name;
	T2 m_Age;
};

template<typename T1, typename T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_Name = name;
	this->m_Age = age;
}

template<typename T1, typename T2>
void Person<T1, T2>::showPerson()
{
	cout << "name= " << this->m_Name << " age= " << this->m_Age << endl;
}

主文件

#include "Person.hpp"

void test01()
{
	Person<string, int> p("Tom", 18);
	p.showPerson();
}

int main()
{
	test01();

	system("pause");
	return 0;
}

1.3.8 类模板和友元

全局函数类内实现 --- 直接在类内声明友元即可

全局函数类外实现 --- 需要提前让编译器知道全局函数的存在

示例：

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

// 全局函数类外实现
template<typename T1, typename T2>
void printPerson2(Person<T1, T2> &p)
{
	cout << "name= " << p.m_Name << " age= " << p.m_Age << endl;
}

template<typename T1, typename T2>
class Person
{
	// 全局函数类内实现
	friend void printPerson(Person<T1, T2> &p)
	{
		cout << "name= " << p.m_Name << " age= " << p.m_Age << endl;
	}

	// 全局函数类外实现
	// 加空模板参数列表
	// 如果全局函数是类外实现，需要让编译器提前知道这个函数的存在
	friend void printPerson2<>(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 test01()
{
	Person<string, int> p("Tom", 18);
	printPerson(p);
	printPerson2(p);
}

int main()
{
	test01();

	system("pause");
	return 0;
}

总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别

2 STL初识

2.1 STL基本概念

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

2.2 STL六大组件

STL大体分为六大组件，分别是：容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

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

2.3 STL中容器、算法、迭代器

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

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

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

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

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

迭代器使用非常类似于指针，初学阶段可以先理解迭代器为指针

迭代器种类：

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

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

2.4 容器算法迭代器初识

2.4.1 vector存放内置数据类型

容器：vector

算法：for_each

迭代器：vector<int>::iterator

示例：

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

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

	system("pause");
	return 0;
}

2.4.2 vector存放自定义数据类型

示例：

int main()
{
    vector<Person> v;
    Person p1("a",10);
    Person p2("b",10);
    Person p3("c",10);
    
    v.push_back(p1);
    v.push_back(p2);
    v.push_back(p3);
    
    //遍历同上
    ...
}

2.4.3 vector容器嵌套容器

示例：

int main()
{
    vector<vector<int>> v; //类似二维数组
    
    vector<int> v1;
    vector<int> v2;
    vector<int> v3;
    
    //添加元素到小容器
    v1.push_back(1);
    v2.push_back(2);
    v3.push_back(3);
    
    //添加小容器到大容器
    v.push_back(v1);
    v.push_back(v2);
    v.push_back(v3);
    
    //遍历
    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 << " ";
        }
        cout << endl;
    }
}

3 STL-常用容器

3.1 string容器

3.1.1 string基本概念

string 本质是一个类

string 和 char* 区别：

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

特点：

string 类内部封装了很多成员方法，例如查找find、拷贝copy、删除delete、替换replace、插入insert

string 管理 char* 所分配的内存，不用担心赋值越界和取值越界等，由类内部进行负责

3.1.2 string构造函数

构造函数原型：

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

3.1.3 string赋值操作

赋值函数原型：

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

3.1.4 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 chat* 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个字符连接到字符串结尾

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

总结：

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

3.1.6 string字符串比较

比较方式：字符串比较是按字符的ASCII码进行对比

= 返回 0
> 返回 1
< 返回 -1

函数原型：

int compare(const string& s) const;
int compare(const char* s) const;

3.1.7 string字符存取

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

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

3.1.8 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个字符

3.1.9 string字串

函数原型：

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

3.2 vector容器

3.2.1 vector基本概念

vector数据结构与数组非常类似，也成为单端数组

vector与普通数组区别：不同之处在于数组是静态空间，而vector是可以动态扩展

动态扩展并不是在原空间之后继续接新空间，而是找更大的内存空间，然后将原数组拷贝到新空间，释放原空间。

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

3.2.2 vector构造函数

函数原型：

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

3.2.3 vector赋值操作

函数原型：

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

3.3.4 vector容量和大小

函数原型：

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

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

3.2.6 vector数据存取

函数原型：

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

3.2.7 vector互换容器

功能：实现两个容器内元素进行呼唤

函数原型：

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

swap可以使两个容器互换，达到适用的收缩内存效果，例如：

vector<int>(v).swap(v);

3.2.8 vector预留空间

功能描述：减少vector在动态扩展容量时的扩展次数

函数原型：

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

示例：

void test01()
{
	vector<int> v;
	//利用reserve预留空间
	v.reserve(100000);

	int num = 0; //统计动态扩展次数
	int *p = NULL;
	for (int i = 0; i < 100000; i++)
	{
		v.push_back(i);

		if (p != &v[0])
		{
			p = &v[0];
			num++;
		}
	}
	cout << "num= " << num << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

3.3 deque容器

3.3.1 deque容器基本概念

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

deque 和 vector区别：

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

deque内部工作原理：

deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据。中控器维护的是每个缓冲区的地址，使得使用deque时就像一片连续的内存空间。

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

3.3.2 deque构造函数

函数原型：

deque<T> deq; 默认构造
deque<T> deq(beg, end); 将迭代器[beg, end)区间的元素拷贝给deq，例如：
```
deque<int> deq(d1.begin(), d1.end()); //将d1所有元素拷贝为deq
```
deque(n, elem); 将n个elem拷贝给本身
deque(const deque &deq); 拷贝构造函数

3.3.3 deque赋值操作

函数原型：

deque& operator=(const deque &deq); 重载=号运算符
assign(beg, end); 将迭代器[beg, end)区间元素拷贝给本身
assign(n, elem); 将n个elem拷贝赋值给本身

3.3.4 deque大小操作

函数原型：

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

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

3.3.5 deque插入和删除

函数原型：

两端插入操作：

push_back(elem); 在容器尾部添加一个数据
push_front(elem); 在容器头部插入一个数据
pop_back(); 删除容器最后一个数据
pop_front(); 删除容器第一个数据

指定位置操作：

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

3.3.6 deque数据存取

函数原型：

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

3.3.7 deque排序

算法：

sort(iterator beg, iterator end); 对 begin 和 end 区间元素进行排序（默认升序）

3.4 stack容器

3.4.1 stack基本概念

stack容器是一种先进后出（First In Last Out，FILO）的数据结构，它只有一个出口

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

栈中进入数据称为：入栈（push）

栈中弹出数据称为：出栈（pop）

3.4.2 stack常用接口

构造函数：

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

赋值操作：

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

数据存取：

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

大小操作：

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

3.5 queue容器

3.5.1 queue容器基本概念

queue容器是一种先进先出（First In First Out，FIFO）的数据结构，它有两个出口

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

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

队列中进数据称为：入队（push）

队列中出数据称为：出队（pop）

3.5.2 queue常用接口

构造函数：

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

赋值操作：

queue &operator=(const queue &que); 重载等号运算符

数据存取：

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

大小操作：

empty(); 判断队列是否为空
size(); 返回队列的大小

3.6 list容器

3.6.1 list容器基本概念

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

链表的组成：链表由一系列结点组成

结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域

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

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

list的优点：

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

list的缺点：

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

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

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

3.6.2 list构造函数

函数原型：

list<T> lst; list采用模板类实现，默认构造
list(beg, end); 将迭代器[beg, end) 区间的元素拷贝给自己
list(n, elem); 将n个elem拷贝给自己
list(const list &lst); 拷贝构造函数

3.6.3 list赋值和交换

函数原型：

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

3.6.4 list大小操作

函数原型：

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

3.6.5 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值匹配的数据

3.6.6 list数据存取

函数原型：

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

list容器不可以通过 [] 或者 at() 方式随机访问元素

3.6.7 list反转和排序

函数原型：

reverse(); 反转链表
sort(); 链表排序
所有不支持随机访问迭代器的容器，不可以用标准算法，但内部会提供对应的成员函数

3.7 set/multiset 容器

3.7.1 set基本概念

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

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

set和multiset区别：

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

3.7.2 set构造和赋值

构造：

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

赋值：

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

3.7.3 set容器大小和交换

函数原型：

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

3.7.4 set插入和删除

函数原型：

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

3.7.5 set查找和统计

函数原型：

find(key); 查找key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回 set.end()
count(key); 统计key的元素个数
对于 set 而言，count要么0 要么1
对于multiset，count可以大于1

3.7.6 set和multiset区别

区别：

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

3.7.7 pair对组创建

利用对组可以返回两个数据

两种创建方式：

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

示例：

void test01()
{
	pair<string, int> p1("Tom", 19);
	cout << "姓名：" << p1.first << " 年龄：" << p1.second << endl;

	pair<string, int> p2 = make_pair("Jerry", 18);
	cout << "姓名：" << p2.first << " 年龄：" << p2.second << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

3.7.8 set容器排序

可以利用 仿函数 改变set容器的排序规则

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

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

void test01()
{
	set<int, MyCompare> s;

	s.insert(10);
	s.insert(30);
	s.insert(20);
	s.insert(40);

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

int main()
{
	test01();

	system("pause");
	return 0;
}

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

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

	string m_Name;
	int m_Age;
};

class MyCompare
{
public:
	//重载()
	bool operator()(const Person &p1, const Person &p2)
	{
		return p1.m_Age > p2.m_Age;
	}
};

void test01()
{
	set<Person, MyCompare> s;
	Person p1("刘备", 24);
	Person p2("关羽", 25);
	Person p3("张飞", 28);
	Person p4("赵云", 21);

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

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

int main()
{
	test01();

	system("pause");
	return 0;
}

3.8 map/multimap 容器

3.8.1 map基本概念

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

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

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

map 和 multimap 区别：

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

3.8.2 map构造和赋值

构造：

map<T1, T2> m; 默认构造函数
map<T1, T2> m2(const map &m1); 拷贝构造函数

赋值：

map &operator=(const map &m); 重载等号运算符

示例：

void test01()
{
	map<int, int> m;

	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(3, 5));
	m.insert(pair<int, int>(2, 11));
	m.insert(pair<int, int>(4, 1));

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

int main()
{
	test01();

	system("pause");
	return 0;
}

总结：map插入数据要用对组

3.8.3 码片大小和交换

函数原型：

size(); 返回容器中元素数目
empty(); 判断容器是否为空
swap(m); 交换两个容器元素

3.8.4 map插入和删除

函数原型：

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

3.8.5 map查找和统计

函数原型：

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

3.8.6 map容器排序

利用 仿函数 改变排序规则

示例：

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

void test01()
{
	map<int, int, MyCompare> m;

	m.insert(pair<int, int>(1, 10));
	m.insert(pair<int, int>(3, 5));
	m.insert(pair<int, int>(2, 11));
	m.insert(pair<int, int>(5, 1));
	m.insert(pair<int, int>(4, 20));

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

int main()
{
	test01();

	system("pause");
	return 0;
}

总结：对于自定义数据类型，map必须指定排序规则，同set容器

4 STL-函数对象

4.1 函数对象

4.1.1 函数对象概念

概念：

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

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

4.1.2 函数对象使用

特点：

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

示例：

class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};

class MyPrint
{
public:
	MyPrint()
	{
		this->count = 0;
	}
	void operator()(string text)
	{
		cout << text << endl;
		this->count++;
	}

	int count; //内部自己状态
};

void doPrint(MyPrint &myPrint, string text)
{
	myPrint(text);
}

void test01()
{
	MyAdd myAdd; //函数对象
	//1、函数对象在使用时，可以像普通函数那样调用，可以用参数，可以有返回值
	cout << myAdd(10, 10) << endl;

	MyPrint myPrint;
	myPrint("Hello, world");
	myPrint("Hello, world");
	myPrint("Hello, world");
	//2、函数对象可以有自己的状态
	cout << "MyPrint调用次数：" << myPrint.count << endl;

	//3、函数对象可以作为参数传递
	doPrint(myPrint, "Hello, C++");
}

int main()
{
	test01();

	system("pause");
	return 0;
}

4.2 谓词

4.2.1 谓词概念

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

4.2.2 一元谓词

示例：

class GreatFive
{
public:
	bool operator()(int val) //一元谓词
	{
		return val > 5;
	}
};

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

	//查找容器中有没有大于5的数字
	//GreatFive() 匿名函数对象
	vector<int>::iterator it = find_if(v.begin(), v.end(), GreatFive());
	if (it == v.end())
	{
		cout << "未找到" << endl;
	}
	else
	{
		cout << "找到了数字为：" << *it << endl;
	}

}

int main()
{
	test01();

	system("pause");
	return 0;
}

4.2.3 二元谓词

示例：

class MyCompare
{
public:
	bool operator()(int v1, int v2) //二元谓词
	{
		return v1 > v2;
	}
};

void test01()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(4);
	v.push_back(2);
	v.push_back(3);
	v.push_back(5);

	sort(v.begin(), v.end(), MyCompare());

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

int main()
{
	test01();

	system("pause");
	return 0;
}

4.3 内建函数对象

4.3.1 内建函数对象意义

STL 内建了一些函数对象，包括：

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

用法：

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

4.3.2 算术仿函数

功能：

实现四则运算
其中 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>
```

示例：

void test01()
{
	negate<int> n;
	cout << n(50) << endl;

	plus<int> p;
	cout << p(10, 10) << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

4.3.3 关系仿函数

实现关系对比

函数原型：

等于
```
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>
```

示例：

void test01()
{
	vector<int> v;
	v.push_back(1);
	v.push_back(3);
	v.push_back(4);
	v.push_back(2);
	v.push_back(5);

	sort(v.begin(), v.end(), greater<int>());

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

int main()
{
	test01();

	system("pause");
	return 0;
}

4.3.4 逻辑仿函数

实现逻辑运算

函数原型：

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

示例：

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

	transform(v.begin(), v.end(), v2.begin(), logical_not<bool>());
	for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

5 STL-常用算法

概述：

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

5.1 常用遍历算法

算法简介：

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

5.1.1 for_each

函数原型：

for_each(iterator beg, iterator end, _func);

参数解释：

beg --- 开始迭代器
end --- 结束迭代器
_func --- 函数或者函数对象

for_each 源码：

因此可以通过重载 () 运算符实现。

示例：

void print01(int val)
{
	cout << val << " ";
}

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

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;
}

5.1.2 transform

函数原型：

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

参数解释：

beg1 --- 原容器开始迭代器
end1 --- 原容器结束迭代器
beg2 --- 目标容器开始迭代器
_func --- 函数或者函数对象

注意：搬运前，目标容器需要开辟空间。

示例：

class Transform
{
public:
	int operator()(int val)
	{
		return val + 100;
	}
};

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());
	cout << endl;
}

int main()
{
	test01();

	system("pause");
	return 0;
}

5.2 常用查找算法

算法简介：

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

5.2.1 find

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

函数原型：

find(iterator beg, iterator end, value);

参数结束：

beg --- 开始迭代器
end --- 结束迭代器
value --- 查找的元素

5.2.2 find_if

函数原型：

find_if(iterator beg, iterator end, _Pred);

参数解释：

beg --- 开始迭代器
end --- 结束迭代器
_Pred --- 函数或者谓词（返回bool类型的仿函数）

5.2.3 adjacent_find

函数原型：

adjacent_find(iterator beg, iterator end);

参数解释：

beg --- 开始迭代器
end --- 结束迭代器

5.2.4 binary_search

要求序列有序！

函数原型：

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

参数解释：

beg --- 开始迭代器
end --- 结束迭代器
value --- 查找的元素

5.2.5 count

函数原型：

count(iterator beg, iterator end, value);

参数解释：

beg --- 开始迭代器
end --- 结束迭代器
value --- 统计的元素

5.2.6 count_if

函数原型：

count_if(iterator beg, iterator end, _Pred);

参数解释：

beg --- 开始迭代器
end --- 结束迭代器
_Pred --- 谓词

5.3 常用排序算法

算法简介：

sort 对容器内元素进行排序
random_shuffle 指定范围内的元素随机调整次序
merge 容器元素合并
reverse 反转指定范围元素

5.4 常用拷贝和替换算法

算法简介：

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

5.5 常用算术生成算法

算法简介：

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

5.6 常用集合算法

算法简介：

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

posted @ 2023-04-07 17:12 柯文先生阅读(28) 评论(0) 收藏举报

刷新页面返回顶部

Kevin

C++提高编程笔记

C++提高编程

1 模板

1.1 模板的概念

1.2 函数模板

1.2.1 函数模板语法

1.2.2 函数模板注意事项

1.2.3 普通函数和函数模板的区别

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

1.2.5 模板的局限性

1.3 类模板

1.3.1 类模板语法

1.3.2 类模板与函数模板区别

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

1.3.4 类模板对象做函数参数

1.3.5 类模板与继承

1.3.6 类模板成员函数类外实现

1.3.7 类模板分文件编写

1.3.8 类模板和友元

2 STL初识

2.1 STL基本概念

2.2 STL六大组件

2.3 STL中容器、算法、迭代器

2.4 容器算法迭代器初识

2.4.1 vector存放内置数据类型

2.4.2 vector存放自定义数据类型

2.4.3 vector容器嵌套容器

3 STL-常用容器

3.1 string容器

3.1.1 string基本概念

3.1.2 string构造函数

3.1.3 string赋值操作

3.1.4 string字符串拼接

3.1.5 string查找和替换

3.1.6 string字符串比较

3.1.7 string字符存取

3.1.8 string插入和删除

3.1.9 string字串

3.2 vector容器

3.2.1 vector基本概念

3.2.2 vector构造函数

3.2.3 vector赋值操作

3.3.4 vector容量和大小

3.2.5 vector插入和删除

3.2.6 vector数据存取

3.2.7 vector互换容器

3.2.8 vector预留空间

3.3 deque容器

3.3.1 deque容器基本概念

3.3.2 deque构造函数

3.3.3 deque赋值操作

3.3.4 deque大小操作

3.3.5 deque插入和删除

3.3.6 deque数据存取

3.3.7 deque排序

3.4 stack容器

3.4.1 stack基本概念

3.4.2 stack常用接口

3.5 queue容器

3.5.1 queue容器基本概念

3.5.2 queue常用接口

3.6 list容器

3.6.1 list容器基本概念

3.6.2 list构造函数

3.6.3 list赋值和交换

3.6.4 list大小操作

3.6.5 list插入和删除

3.6.6 list数据存取

3.6.7 list反转和排序

3.7 set/multiset 容器

3.7.1 set基本概念

3.7.2 set构造和赋值

3.7.3 set容器大小和交换

3.7.4 set插入和删除

3.7.5 set查找和统计

3.7.6 set和multiset区别

3.7.7 pair对组创建

3.7.8 set容器排序

3.8 map/multimap 容器