文章目录
- 一、模板
- 1.1 定义
- 1.2 作用
- 1.3 函数模版
- 1.3.1 格式
- 1.4 类模版
- 1.4.1 格式
- 1.4.2 代码示例
- 1.4.3 特性
- 二、容器
- 2.1 概念
- 2.2 容器特性
- 2.3 分类
- 2.4 向量vector
- 2.4.1 特性
- 2.4.2 初始化与操作
- 2.4.3 插入删除
- 2.5 迭代器
- 2.6 列表（list）
- 2.6.1 遍历方式
- 2.6.2 插入与删除操作
- 2.7队列（Deque）
- 2.7.1定义与基本特性
- 2.7.2 内部实现机制
- 2.8. map 容器
- 2.8.1 特性
- 2.8.2 定义格式
- 2.8.3 遍历方式
- 2.8.4 插入删除查找操作
- 三、C++异常处理详解
- 3.1 异常基本概念
- 3.2 异常处理机制
- 3.3 简易异常实现
- 3.4 标准异常
- 3.5 自定义异常
- 四、文件流
- 总结
一、模板
1.1 定义
C++模板是支持参数化多态的工具，允许类或函数声明为通用类型，使得其数据成员、参数或返回值在实际使用时可以是任意类型。模板通过编译器生成具体代码，实现类型无关的逻辑复用。
1.2 作用
实现泛型编程，提高代码的通用性和复用性。
避免为不同数据类型重复编写相同逻辑的代码。
1.3 函数模版
1.3.1 格式
template <typename T1, typename T2, ...>
返回类型 函数名(参数列表) {
// 函数体
}
- 关键字 typename 或 class 均可用于声明类型参数，typename 更推荐（尤其在处理依赖类型时)。
代码示例
#include<iostream>
using namespace std;
// 通用加法函数模板
// T: 第一个参数和返回值的类型
// C: 第二个参数的类型
// 当T和C类型不同时，返回值类型与第一个参数类型保持一致
template <class T, class C>
T add(T a, C b) {
return a + b;
}
int main() {
// 测试整型相加（int + int）
cout << add(1, 2) << endl;
// 测试浮点型相加（double + double）
cout << add(1.1, 2.2) << endl;
// 测试字符类型相加（char + char），ASCII码值运算
cout << add('A',' ') << endl;
// 测试字符串拼接（string + string）
string s1 = "Hello";
string s2 = "World";
cout << add(s1, s2) << endl;
// 测试混合类型相加（int + char），返回int类型
cout << add(32, 'A') << endl;
// 测试混合类型相加（double + int），返回double类型
cout << add(32.1, 2) << endl;
return 0;
1.4 类模版
1.4.1 格式
template <typename T1, typename T2, ...>
class 类名 {
// 类成员
};
1.4.2 代码示例
#include<iostream>
using namespace std;
// 定义一个模板类Test，T为泛型类型参数
template <class T>
class Test{
public:
// 构造函数，使用类型T的参数初始化成员变量num
Test(T n):num(n){}
// 声明公有成员函数getVal，返回类型为T，const表示不修改对象状态
T getVal()const;
private:
T num; // 私有成员变量，类型为T
};
// 类外定义模板成员函数getVal()
// 注意模板类成员函数在类外定义时需要再次声明模板参数
template <class T>
T Test<T>::getVal()const{
return num; // 返回成员变量num的值
}
int main()
{
// 实例化Test类，指定类型参数为int，并初始化值为100
Test<int> tt(100);
// 调用getVal()获取存储的值并输出
cout << tt.getVal() << endl; // 输出: 100
// 实例化Test类，指定类型参数为float，并初始化值为3.14
Test<float> t1(3.14);
cout << t1.getVal() <<endl; // 输出: 3.14
return 0;
}
1.4.3 特性
- 作用域限制：模板只能在全局、命名空间或类作用域中声明，不能在局部作用域（如函数内）定义。
- 成员函数定义：类外定义时需重复模板声明，并使用 类名:: 限定作用域。
- 显式实例化：使用类模板时必须指定具体类型参数。
二、容器
2.1 概念
C++标准模板库（STL）提供基于模板的通用组件，包含容器、迭代器、算法等核心部件，用于高效处理数据存储和操作任务。
2.2 容器特性
类型一致性： 容器内元素类型必须相同（与Python不同）
内存管理：
默认使用栈内存，无需手动new/delete
动态容器（如vector）自动管理堆内存
操作效率： 不同容器对插入/删除/随机访问的性能差异显著
2.3 分类
| 类型 | 容器 | 特性 |
|---|---|---|
| 顺序容器 | vector | 动态数组，连续内存，随机访问高效 |
| list | 双向链表，非连续内存，插入删除高效 | |
| deque | 双端队列，分段连续内存，首尾操作高效 | |
| 关联容器 | map | 红黑树实现，键值对有序存储，键唯一 |
| set | 有序唯一键集合 | |
| unordered_map | 哈希表实现，无序存储，平均O(1)访问 |
2.4 向量vector
2.4.1 特性
底层结构： 动态数组
时间复杂度：
随机访问：O(1)
尾部操作：O(1)
中间插入/删除： O(n)
头文件： #include < vector >
2.4.2 初始化与操作
#include <vector>
using namespace std;
int main()
{
// 定义一个空的vector对象v1，使用默认构造函数初始化
vector <int>v1;
// 定义一个有5个元素的向量v2，元素进行值初始化（int类型默认初始化为0）
vector <int>v2(5);
// 定义一个有5个元素的向量v3，每个元素的初始值均为4
vector <int>v3(5, 4);
// 使用C++11的列表初始化定义向量v4，直接包含元素{5,6,4,3,2}
// 此语法需要编译器支持C++11及以上标准
vector <int>v4{5,6,4,3,2};
}
在QT编译中支持C++11版本的修改方式：
在.pro中增加下面内容：
CONFIG += c++11
#include<iostream>
#include <vector>
using namespace std;
int main()
{
// 使用C++11的列表初始化语法创建并初始化vector
vector <int> v4{5, 6, 4, 3, 2};
// 使用传统的for循环遍历vector
for(int i = 0; i < v4.size(); i++){
// 使用at()成员函数访问元素，at()会进行边界检查，更安全
cout << v4.at(i) << endl;
}
// 使用下标操作符修改vector中的元素
// 注意：下标操作符不进行边界检查，访问越界会导致未定义行为
v4[3] = 100;
// 使用C++11的范围for循环遍历vector
// 这种语法更简洁，i依次获取v4中的每个元素的副本
for(int i : v4){
cout << i << endl;
}
return 0; // 表示程序正常结束
}
2.4.3 插入删除
int main()
{
// 创建并初始化一个整型vector容器
vector<int> v4{5, 6, 4, 3, 2};
// 清除容器（当前被注释）
// v4.clear();
// 判断容器是否为空（1表示空，0表示非空）（当前被注释）
// cout << v4.empty() << endl;
// 在容器尾部追加元素（注意类型转换）
v4.push_back(10); // 直接追加整型
v4.push_back(20.5); // double类型会被截断为整型20
v4.push_back('a'); // char类型会转换为ASCII码97
// 迭代器操作（当前被注释）
// cout << *(v4.begin()+2) << endl; // 访问第3个元素（下标2）
// cout << *(v4.end()-1) << endl; // 访问最后一个元素
// 在容器头部插入元素222
v4.insert(v4.begin(), 222);
// 在倒数第三个位置插入元素333
v4.insert(v4.end() - 2, 333);
// 移除容器最后一个元素（当前会移除ASCII码97对应的元素）
v4.pop_back();
// 移除容器第一个元素（当前会移除头部元素222）
v4.erase(v4.begin());
// 遍历输出容器当前所有元素
// 最终元素顺序：5,6,4,3,2,10,20,333,97 -> 经过删除操作后变为：
// 6,4,3,2,10,333,20（注意实际执行后建议调试验证）
for(int i : v4) {
cout << i << endl;
}
return 0;
}
2.5 迭代器
类型：
iterator：可读写
const_iterator：只读
reverse_iterator：反向遍历
失效问题： 容器结构变更（如vector扩容）可能导致迭代器失效
容器类型 <数据类型>::iterator 迭代器变量名;
容器类型 <数据类型>::const_iterator 迭代器变量名;
#include<iostream> // 引入输入输出流库
#include <vector> // 引入向量容器库
using namespace std; // 使用标准命名空间，避免std::前缀
int main()
{
// 创建并初始化整型向量v4，包含元素5,6,4,3,2
vector <int>v4{5,6,4,3,2};
// 定义可读写的迭代器，指向向量v4的起始位置
vector <int>::iterator it = v4.begin();
// 若使用const_iterator则无法通过迭代器修改元素（注释掉的备用方案）
// vector <int>::const_iterator it = v4.begin();
// 通过迭代器修改向量第一个元素的值
*it = 100;
// 使用迭代器遍历向量：从当前位置(it)开始，直到超过末尾(end)
for(; it < v4.end();it++)
cout << *it << endl; // 解引用迭代器，输出当前元素值
return 0; // 程序正常退出
}
2.6 列表（list）
列表是C++标准模板库（STL）中的双向链表实现。其特点如下：
内部结构： 由双向链表实现，元素内存地址不连续，通过指针链接。
访问特性：
不支持随机访问（不能使用at()或[]操作符）。
需通过迭代器顺序访问，迭代器类型为双向迭代器（仅支持++、–操作）。
性能特点：
擅长任意位置的插入和删除操作（时间复杂度为 O(1)，但需先遍历到操作位置）。
与vector功能互补： vector长于随机访问和尾部操作，list长于频繁插入删除。
2.6.1 遍历方式
#include<iostream> // 输入输出流头文件
#include<list> // 列表容器头文件
using namespace std; // 标准命名空间
int main()
{
list <int>ls{4, 3, 2, 5, 1, 6}; // 初始化双向链表容器
// 通过双向迭代器进行遍历（不支持随机访问）
list <int>::iterator it = ls.begin(); // 获取起始迭代器
// list迭代器只能使用前/后递增运算符移动
// 注意：迭代器自增后指向第二个元素(3)
cout << *(++it) << endl; // 输出：3
// 从第二个元素开始遍历（当前迭代器已自增）
for(; it != ls.end(); it++){ // 遍历直到链表末尾
cout << *it << endl; // 输出：3 → 2 → 5 → 1 → 6
}
return 0;
}
2.6.2 插入与删除操作
基础操作（与vector类似）：
list<int> ls{4, 3, 2, 5, 1, 6};
// 头部操作
ls.push_front(100); // 头部插入
ls.pop_front(); // 头部删除
// 尾部操作
ls.push_back(99); // 尾部插入
ls.pop_back(); // 尾部删除
// 访问首尾元素
cout << "Head: " << ls.front() << endl; // 输出头部元素
cout << "Tail: " << ls.back() << endl; // 输出尾部元素
列表特有操作：
排序：
ls.sort(); // 默认升序排序（成员函数，时间复杂度O(n log n)）
注意：需使用成员函数sort()，而非标准库的std::sort()（因后者需随机访问迭代器）。
去重：
ls.unique(); // 移除相邻重复元素（通常先排序后使用）
合并链表：
list<int> ls2{7, 8, 9};
ls.merge(ls2); // 合并后ls2为空，ls包含合并后的有序元素（需双方已排序）
删除特定值：
ls.remove(3); // 删除所有值为3的元素
反转链表：
ls.reverse(); // 反转链表顺序
2.7队列（Deque）
2.7.1定义与基本特性
双端队列（Double-Ended Queue，Deque）是一种允许在头部和尾部高效插入、删除元素的线性数据结构。它结合了向量（动态数组）和链表的优点，支持两端操作的时间复杂度为 ，同时提供接近向量的随机访问性能。
2.7.2 内部实现机制
分块存储结构
Deque 内部由多个固定大小的数组块组成，每个块独立分配内存。
当头部或尾部空间不足时，仅需分配新块并链接，无需整体复制（如向量扩容）。
例如：一个典型的实现可能维护一个中央索引数组，记录所有块的地址，通过计算快速定位元素。
高效的两端操作
头部插入/删除：若当前头块未满，直接操作；否则分配新块。
尾部插入/删除：类似头部逻辑，尾部块不足时扩展新块。
2.8. map 容器
2.8.1 特性
关联容器： 键值对（Key-Value）存储，类似 Python 的 dict。
底层实现： 基于红黑树（自平衡二叉搜索树），保证元素按键有序（默认升序）。
时间复杂度： 插入、删除、查找操作的平均和最坏时间复杂度均为 O(log n)。
键的特性：
唯一性： 键不可重复。
有序性： 键自动排序，需支持比较操作（默认 operator<）。
迭代器稳定性：
插入操作不会使迭代器失效（除非容器被销毁）。
删除操作仅影响被删除元素的迭代器。
2.8.2 定义格式
#include <map>
using namespace std;
// 默认定义（升序）
map<KeyType, ValueType> myMap;
// 自定义排序规则
struct Compare {
bool operator()(const KeyType& a, const KeyType& b) const {
return a > b; // 降序排列示例
}
};
map<KeyType, ValueType, Compare> customOrderMap;
2.8.3 遍历方式
#include<iostream> // 输入输出流头文件
#include<map> // 关联容器头文件（键值对存储）
using namespace std; // 标准命名空间
int main()
{
// 初始化map容器（键:string类型，值:int类型）
map <string, int> mp = {{"num",101},{"age", 20}};
// 通过下标运算符修改值
mp["num"] = 200; // 修改键"num"对应的值
cout << mp["num"] << endl; // 输出：200
// 通过at方法安全访问值（会检查键是否存在）
cout << mp.at("age") << endl; // 输出：20
// 通过双向迭代器遍历map
map <string, int>::iterator it = mp.begin();
for(; it != mp.end(); it++){
// first访问键，second访问值
cout << it->first << ":" << it->second << endl; // 输出键值对
}
return 0;
}
2.8.4 插入删除查找操作
#include<iostream> // 输入输出流头文件
#include<map> // 关联容器头文件（键值对存储）
using namespace std; // 标准命名空间
int main()
{
map <string, int> mp = {{"num",101},{"age", 20}};
// 通过pair对象插入新键值对
mp.insert(pair<string, int>("weight", 88)); // 显式构造pair插入
// 使用make_pair自动推导类型插入
mp.insert(make_pair("name", 123)); // 更简洁的pair创建方式
// 通过键值删除元素（删除"age"对应的键值对）
mp.erase("age"); // 返回删除元素的数量
// 查找键"num"并输出对应值（需确保存在）
cout << mp.find("num")->second << endl; // 输出：101
// 安全查找机制：验证find结果是否为有效迭代器
if(mp.find("num") != mp.end()){ // 判断是否找到键
mp["num"] = 18; // 安全修改值
}
else{
cout << "没有找到" << endl; // 未找到时的处理
}
return 0;
}
三、C++异常处理详解
3.1 异常基本概念
定义：程序运行期间发生的非正常情况（如除零错误、越界访问等）。
核心作用：通过throw抛出异常、try监控代码块、catch捕获异常，实现错误控制权的转移，避免程序崩溃。
处理必要性：未处理的异常会导致程序终止。
3.2 异常处理机制
关键字：throw、try、catch
语法结构：
try {
// 可能抛出异常的代码（保护代码）
} catch (ExceptionType1& e1) {
// 处理 ExceptionType1 类型异常
} catch (ExceptionType2& e2) {
// 处理 ExceptionType2 类型异常
} catch (...) {
// 捕获所有其他类型异常
}
3.3 简易异常实现
#include<iostream> // 输入输出流头文件
using namespace std; // 标准命名空间
// 带异常检查的除法函数
// 参数：a-被除数，b-除数
// 返回值：整型除法结果
int divs(int a, int b)
{
if(b == 0){ // 检查除数合法性
string s("除数为0"); // 创建异常描述字符串
throw s; // 抛出字符串类型异常
}
return a/b; // 执行安全除法运算
}
int main()
{
try{ // 异常监控代码块
// 调用可能抛出异常的除法运算
cout << divs(4, 0) << endl; // 触发异常的调用点
}
catch(string &s){ // 捕获字符串类型异常
cout << s << endl; // 输出异常描述信息
}
return 0; // 程序正常退出
}
3.4 标准异常
头文件： < stdexcept >（提供常见异常类型如invalid_argument、out_of_range等）。
特点：
标准异常类继承自std::exception，通过多态统一处理。
使用what()方法获取错误信息。
示例：
#include<iostream> // 输入输出流头文件
using namespace std; // 标准命名空间
// 带异常检查的除法函数
// 参数：a-被除数，b-除数
// 返回值：整型除法结果
int divs(int a, int b)
{
if(b == 0){ // 检查除数合法性
// 抛出标准库异常对象（比原始字符串更规范）
throw invalid_argument("除数为0"); // 构造带错误信息的异常对象
}
return a/b; // 执行安全除法运算
}
int main()
{
try{ // 异常监控代码块
// 调用可能抛出异常的除法运算
cout << divs(4, 0) << endl; // 触发异常的调用点
}
catch(exception &e){ // 通过基类引用捕获所有派生异常
// 调用虚函数what()获取异常描述
cout << e.what() << endl; // 输出：除数为0
}
return 0; // 程序正常退出
}
3.5 自定义异常
实现步骤：
继承自std::exception或其子类。
重写what()方法，返回错误描述（需保证返回的字符串有效性）。
#include<iostream> // 输入输出流头文件
using namespace std; // 标准命名空间
// 自定义异常类（继承标准异常体系）
class MyExcept:public exception{ // 继承自exception基类
public:
// 异常描述方法（符合C++标准异常规范）
// 第一个const: 返回不可修改的字符串指针
// 第二个const: 承诺不修改对象状态
// throw(): 空异常规格（C++11前表示不抛出任何异常）
const char * what() const throw(){ // 重写虚函数
return "除数为0"; // 返回固定错误描述
}
};
// 带异常检查的除法运算
int divs(int a, int b)
{
if(b == 0){ // 检查除数合法性
MyExcept me; // 创建异常对象实例
throw me; // 抛出符合标准的异常对象
}
return a/b; // 执行安全除法运算
}
int main()
{
try{ // 异常监控代码块
cout << divs(4, 0) << endl; // 触发异常的调用点
}
catch(exception &e){ // 多态捕获标准异常体系
cout << e.what() << endl; // 通过虚函数获取描述信息
}
return 0; // 程序正常退出
}
四、文件流
头文件
#include <fstream> // 包含文件流操作所需的类
#include <iostream> // 用于错误输出（如 cerr）
#include <string> // 用于字符串处理
核心类
ofstream： 输出文件流，用于写入文件（默认模式：ios::out）。
ifstream： 输入文件流，用于读取文件（默认模式：ios::in）。
fstream： 多功能文件流，支持读写（需手动指定模式）。
#include<iostream> // 输入输出流头文件
#include <fstream> // 文件流操作头文件
using namespace std; // 标准命名空间
int main()
{
// 1. 文件打开操作
// 以二进制模式打开源文件（注意相对路径的基准目录）
ifstream inf("../25011test/mystring.cpp", ios_base::binary);
if(!inf){ // 文件打开失败处理
cout << "打开读文件失败" << endl;
return 1; // 立即终止程序
}
// 以二进制模式创建/覆盖目标文件
ofstream outf("../25011test/test.cpp", ios_base::binary);
if(!outf){ // 文件创建失败处理
cout << "打开写文件失败" << endl;
return 1; // 立即终止程序
}
// 2. 文件读写操作
char buf[32] = ""; // 固定缓冲区（存在溢出风险）
inf.read(buf, 31); // 读取最多31字节（预留结尾空字符）
cout << buf << endl; // 输出到控制台（二进制数据可能乱码）
// 精确写入实际读取的字节数
outf.write(buf, inf.gcount()); // gcount()获取最后一次读取的字节数
// 3. 资源清理
inf.close(); // 关闭输入文件流（可省略，析构时自动关闭）
outf.close(); // 关闭输出文件流（同上）
return 0; // 正常退出程序
}
练习： 实现文件复制
#include<iostream> // 输入输出流头文件
#include <fstream> // 文件流操作头文件
using namespace std; // 标准命名空间
int main()
{
// 1. 文件打开操作
// 以二进制模式打开源文件（注意相对路径的基准目录）
ifstream inf("../25011test/mystring.cpp", ios_base::binary);
if(!inf){ // 文件打开失败处理
cout << "打开读文件失败" << endl;
return 1; // 立即终止程序（新增错误处理）
}
// 以二进制模式创建/覆盖目标文件
ofstream outf("../25011test/test.cpp", ios_base::binary);
if(!outf){ // 文件创建失败处理
cout << "打开写文件失败" << endl;
return 1; // 立即终止程序（新增错误处理）
}
// 2. 文件读写操作
char buf[32] = ""; // 固定缓冲区（32字节容量）
while(true){ // 循环读取直到文件结束
inf.read(buf, 31); // 每次读取31字节（预留空字符位）
// 检测实际读取字节数（0表示到达文件末尾）
if(inf.gcount() == 0) // gcount()获取最后一次读取的字节数
break;
outf.write(buf, inf.gcount()); // 精确写入实际读取的字节数
}
// 3. 资源清理（可省略，析构时会自动关闭）
inf.close(); // 显式关闭输入文件流
outf.close(); // 显式关闭输出文件流
return 0; // 正常退出程序
}
总结
本文系统讲解C++模板机制实现泛型编程的原理，涵盖函数模板与类模板的语法特性及代码实践，深入剖析STL容器分类（顺序容器、关联容器）及其底层数据结构差异，通过vector、list、map等典型容器演示增删查改操作，详细解析异常处理流程包括标准异常与自定义异常实现，最后结合文件流操作示例展示二进制读写与安全处理方案，全面覆盖C++高效编程核心知识点。
