C++核心编程解析：模板、容器与异常处理全指南

---

一、模板

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的参数初始化成员变量numTest(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，并初始化值为100Test<int> tt(100);// 调用getVal()获取存储的值并输出cout << tt.getVal() << endl; // 输出: 100// 实例化Test类，指定类型参数为float，并初始化值为3.14Test<float> t1(3.14);cout << t1.getVal() <<endl; // 输出: 3.14return 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，每个元素的初始值均为4vector <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的列表初始化语法创建并初始化vectorvector <int> v4{5, 6, 4, 3, 2};// 使用传统的for循环遍历vectorfor(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类型会被截断为整型20v4.push_back('a');        // char类型会转换为ASCII码97// 迭代器操作（当前被注释）//    cout << *(v4.begin()+2) << endl;  // 访问第3个元素（下标2）//    cout << *(v4.end()-1) << endl;    // 访问最后一个元素// 在容器头部插入元素222v4.insert(v4.begin(), 222);// 在倒数第三个位置插入元素333v4.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,2vector <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// 通过双向迭代器遍历mapmap <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++高效编程核心知识点。