多态
一、概念
多态是指不同对象对同一消息产生不同响应的行为。例如，蓝牙、4G、Wi-Fi 对“发送数据”指令有不同的具体实现。
二、核心理解
-
本质：通过基类指针或引用操作子类对象，实现运行时动态绑定。
-
表现形式：
-
接口统一：基类定义通用接口（如
virtual void TransmitData()）。 -
实现多样：子类重写接口，提供具体功能（如蓝牙发送数据的具体逻辑）。
-
三、分类与对比
| 类型 | 静态多态（早绑定） | 动态多态（晚绑定） |
|---|---|---|
| 实现方式 | 函数重载、模板 | 虚函数（virtual） |
| 绑定时机 | 编译期确定调用函数 | 运行时根据对象类型确定调用函数 |
| 灵活性 | 低（依赖编译时类型） | 高（支持运行时多态） |
四、作用与意义
-
通用性：将不同子类对象视为基类对象，编写统一代码。
SendData* devices[] = {new Bluetooth(), new A4G(), new WiFi()}; for (auto device : devices) { device->TransmitData(); // 统一接口，不同实现 } -
扩展性：新增子类无需修改现有代码（如新增 ZigBee 模块）。
-
解耦：分离接口与实现，降低代码依赖性。
五、实现前提条件
-
继承关系：必须存在基类与子类的继承结构。
-
虚函数重写：基类方法用
virtual声明，子类重写该方法。 -
基类引用/指针指向子类对象：通过基类操作实际子类对象。
六、实现步骤（以物联网设备为例）
-
定义基类虚函数：
class SendData { public: virtual void TransmitData() = 0; // 纯虚函数 virtual ~SendData() = default; // 虚析构函数 }; -
子类继承并重写虚函数：
class Bluetooth : public SendData { public: void TransmitData() override { cout << "蓝牙发送数据..." << endl; } }; -
使用基类指针操作子类对象：
int main() { SendData* device = new Bluetooth(); device->TransmitData(); // 动态调用 Bluetooth 的实现 delete device; return 0; }
七、应用场景示例（物联网设备数据传输）
-
需求：统一管理蓝牙、4G、Wi-Fi 的数据传输接口。
-
设计：
-
基类
SendData定义虚函数TransmitData()。 -
子类
Bluetooth、A4G、WiFi分别实现具体传输逻辑。 -
客户端通过基类指针调用接口，无需关心具体设备类型。
-
八、注意事项
-
虚析构函数：基类必须声明虚析构函数，确保正确释放子类资源。
-
避免切片问题：使用指针或引用传递对象，而非值传递。
-
纯虚函数：若基类仅定义接口，可声明为纯虚函数（
= 0），使基类成为抽象类。
代码示例：
//4G通讯
#include <iostream>
#include "send_data.h"
#include <cstring>
#ifndef __A4G__HEAD__
#define __A4G__HEAD__
using namespace std;
class A4G:public Send_data
{
private:char* data;
public:A4G(const char* data);void Transmit_data();virtual ~A4G();
};
//构造函数
A4G::A4G( const char* data)
{cout << "构造函数" << endl;this->data = new char[strlen(data) + 1]; // 分配内存strcpy(this->data, data); // 复制内容
}void A4G::Transmit_data(){cout << "用4G发送数据:" << this->data << endl;
}A4G::~A4G()
{cout << "~A4G" << endl;
}#endif //蓝牙通讯
#include <iostream>
#include "send_data.h"
#include <cstring>
#ifndef __Blue_tooth__HEAD__
#define __Blue_tooth__HEAD__
using namespace std;
class Blue_tooth:public Send_data
{
private:char* data;
public:Blue_tooth(const char* data);void Transmit_data();virtual ~Blue_tooth();
};
//构造函数
Blue_tooth::Blue_tooth(const char* data)
{cout << "构造函数" << endl;this->data = new char[strlen(data) + 1]; // 分配内存strcpy(this->data, data); // 复制内容
}void Blue_tooth::Transmit_data(){cout << "用蓝牙发送数据:" << this->data << endl;
}Blue_tooth::~Blue_tooth()
{cout << "~Blue_tooth" << endl;delete []data;
}#endif // DEBUG//WiFi通讯
#include <iostream>
#include "send_data.h"
#ifndef __Wifi__HEAD__
#define __Wifi__HEAD__
using namespace std;
class Wifi:public Send_data
{
private:char* data;
public:Wifi(const char* data);void Transmit_data();virtual ~Wifi();
};
//构造函数
Wifi::Wifi(const char* data)
{cout << "构造函数" << endl;this->data = new char[strlen(data) + 1]; // 分配内存strcpy(this->data, data); // 复制内容
}void Wifi::Transmit_data(){cout << "用Wifi发送数据:" << this->data << endl;
}Wifi::~Wifi()
{cout << "~Wifi" << endl;//delete []data;
}#endif // DEBUG//主函数
#include "4G.h"
#include "bluetooth.h"
#include "send_data.h"
#include "wifi.h"
#include <iostream>int main(){
//——————————————————————————这里是使用指针——————————————————————————// A4G* fg = new A4G("今天天气良好") ;// fg->Transmit_data();// Blue_tooth* bt = new Blue_tooth("今天天气良好") ;// bt->Transmit_data();// Wifi* wf =new Wifi("今天天气良好") ;// wf->Transmit_data();
//__________________________这里使用引用——————————————————————————————\
//自动析构
A4G fg = A4G("今天天气良好") ;
fg.Transmit_data();
//自动析构
Blue_tooth bt = Blue_tooth("今天天气良好") ;
bt.Transmit_data();// Blue_tooth* bt = new Blue_tooth("今天天气良好") ;
// bt->Transmit_data();Wifi* wf =new Wifi("今天天气良好") ;
wf->Transmit_data();
delete wf;return 0;
}
多态实现原理
一、虚函数表（vtable）与虚指针（vptr）
核心机制
虚函数表（vtable）：每个包含虚函数的类在编译时生成一个虚函数表，表中存储该类所有虚函数的地址。
虚指针（vptr）：每个对象在内存中隐含一个指向其虚函数表的指针（
vptr），用于运行时动态绑定。内存布局示例
class Hero { public:virtual void skill() {}string name;static int count; };
32位系统：
vptr占4字节，string占24字节（实现依赖），总大小4 + 24 = 28字节（对齐可能调整）。64位系统：
vptr占8字节，string占32字节（实现依赖），总大小8 + 32 = 40字节。调试验证（GDB）
调试程序
gdb a.out
设置断点
b 函数名/行号
运行调试
r
单步执行
n
- set print object on/off 是否以更易于阅读的方式打印结构体或类对象
- set print pretty on/off 控制数组打印
- set print array on 查看对象信息
- print object 数据显示格式
- x 按十六进制格式显示变量
- d 按照十进制格式显示变量
- u 按十六进制格式显示无符号整型
- o 按八进制格式显示变量
- t 按二进制格式显示变量
- a 按十六进制格式显示变量
- c 按字符格式显示变量
- f 按浮点数格式显示变量
虚函数表
-
虚函数表（vtable）是C++中实现多态性的核心机制，它存放了类中虚函数的入口地址。
-
_vptr是每个包含虚函数的类的对象中的一个隐藏指针，指向该类的虚函数表。
-
编译器自动生成和维护虚函数表以及_vptr，开发者无需手动干预。
-
在GDB中调试时，可以查看_vptr的值以及它所指向的虚函数表，以了解对象的多态行为。
二、继承与虚函数表覆盖
-
子类继承父类虚函数表
-
子类继承父类的虚函数表，若重写父类虚函数，则替换对应条目。
-
示例：
class Houyi : public Hero { public:virtual void skill() override {} };-
子类
Houyi的虚函数表中skill()地址指向Houyi::skill()。
-
-
-
调试验证
(gdb) print houyi $1 = (Houyi) {<Hero> = {_vptr.Hero = 0x56558e7c <vtable for Houyi+8>},looks = 20 }
三、静态绑定与动态绑定
| 特性 | 静态绑定 | 动态绑定 |
|---|---|---|
| 绑定时机 | 编译期（根据类型确定调用） | 运行期（根据对象实际类型确定） |
| 实现方式 | 函数重载、模板 | 虚函数（virtual） |
| 灵活性 | 低 | 高 |
关键区别：
-
动态绑定依赖虚函数表：通过
vptr找到虚函数表，再根据实际对象类型调用对应函数。 -
多态场景：必须通过基类指针或引用操作子类对象。
四、32位与64位系统下的对象大小
-
基本规则
-
指针大小：32位系统4字节，64位系统8字节。
-
内存对齐：通常按最大成员类型对齐（如
int按4字节对齐）。
-
-
复杂继承示例
class C : public A, public B {int c; };-
32位系统：
-
A含vptr（4） +int a（4） = 8字节。 -
B含vptr（4） +int b（4） = 8字节。 -
C含A（8） +B（8） +int c（4） = 20字节（对齐到8的倍数→24字节）。
-
-
64位系统：
-
A含vptr（8） +int a（4） → 对齐到8字节 → 16字节。 -
B含vptr（8） +int b（4） → 对齐到8字节 → 16字节。 -
C总大小：16 + 16 + 4 = 36 → 对齐到8的倍数→40字节。
-
-
六、总结
-
多态实现核心：虚函数表与虚指针的动态绑定机制。
-
内存管理关键：理解不同系统下的指针大小和对齐规则。
-
调试工具：GDB可用于验证虚函数表和对象内存布局。
-
设计原则：优先使用虚函数实现动态多态，避免手动管理内存错误。
重载、覆盖和隐藏
一、重载（Overloading）
定义：在同一作用域内定义多个同名函数或运算符，但参数列表（参数类型、数量或顺序）不同。
特点：
-
编译时多态，由编译器根据参数列表决定调用哪个函数。
-
适用于函数和运算符。
-
函数签名必须不同（返回类型不影响）。
-
const修饰符、引用或指针类型的参数可区分重载。
示例：
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }二、覆盖（Overriding）
定义：派生类重新定义基类的虚函数，实现运行时多态。
条件：
-
基类函数必须为虚函数（
virtual）。 -
函数签名（名称、参数列表、返回类型）完全相同。
-
访问权限可以不同，但通常保持一致。
特点：
-
通过基类指针或引用调用时，实际执行派生类的函数。
-
依赖虚函数表（vtable）实现动态绑定。
示例：
class Base {
public: virtual void show() { cout << "Base"; }
};
class Derived : public Base {
public: void show() override { cout << "Derived"; }
};三、隐藏（Hiding）
定义：派生类中的成员（函数或属性）与基类同名，导致基类成员在派生类作用域中不可见。
类型：
-
函数隐藏：
-
派生类函数与基类函数同名但参数不同，或同名同参数但基类函数非虚。
-
基类函数被隐藏，需通过作用域解析符（
Base::func()）访问。
-
-
属性隐藏：
-
派生类定义与基类同名的成员变量，直接访问时使用派生类版本。
-
示例：
class Base {
public: void func() { cout << "Base::func"; } int value;
};
class Derived : public Base {
public: void func(double) { cout << "Derived::func"; } // 隐藏Base::func() double value; // 隐藏Base::value
};关键区别
| 特性 | 重载 | 覆盖 | 隐藏 |
|---|---|---|---|
| 作用域 | 同一作用域 | 基类与派生类之间 | 基类与派生类之间 |
| 函数签名 | 必须不同 | 必须相同 | 可不同或相同（非虚） |
| 虚函数 | 不要求 | 必须为虚函数 | 不要求 |
| 多态性 | 编译时多态 | 运行时多态 | 无多态性 |
抽象类与泛型
一、抽象类（Abstract Class）
定义：
抽象类是一种不能被实例化的类，用于定义接口或基类，要求派生类必须实现其纯虚函数。
核心特点：
-
纯虚函数：
-
声明格式为
virtual 返回类型 函数名() = 0;，无函数体。 -
派生类必须实现所有纯虚函数，否则派生类仍为抽象类。
class AbstractClass { public:virtual void pureVirtual() = 0; // 纯虚函数 }; -
-
不能实例化：
-
直接实例化抽象类会导致编译错误。
AbstractClass obj; // 错误：无法创建抽象类对象 -
-
基类作用：
-
抽象类通过指针或引用实现多态，指向派生类对象。
AbstractClass* ptr = new DerivedClass(); ptr->pureVirtual(); // 调用派生类的实现 -
-
构造与析构函数：
-
抽象类可以有构造函数和析构函数，但析构函数通常声明为虚函数以确保正确释放资源。
-
应用场景：
-
定义统一接口：要求所有派生类遵循相同的接口规范。
-
代码复用：基类提供公共逻辑，派生类实现具体功能。
示例：
class Shape { // 抽象类
public:virtual double area() = 0; // 纯虚函数virtual ~Shape() {} // 虚析构函数
};class Circle : public Shape {
private:double radius;
public:Circle(double r) : radius(r) {}double area() override { // 必须实现纯虚函数return 3.14 * radius * radius;}
};二、泛型（Generics）
定义：
泛型编程通过模板（Templates）实现类型无关的代码，支持在编译时根据具体类型生成代码。
核心机制：
-
函数模板：
-
定义与类型无关的通用函数，支持多种数据类型。
template <typename T> T add(T a, T b) {return a + b; }-
调用方式：
-
自动推导：
add(3, 4); -
显式指定：
add<double>(3.14, 2.71);
-
-
-
类模板：
-
定义与类型无关的类，成员变量和函数的类型由模板参数决定。
template <typename T> class Box { private:T content; public:Box(T c) : content(c) {}T getContent() { return content; } }; -
-
模板继承：
-
派生类继承类模板时，需指定父类的具体类型或自身也声明为模板。
template <typename T> class Base { /* ... */ };class DerivedInt : public Base<int> { /* ... */ }; // 指定类型template <typename T1, typename T2> class DerivedTemplate : public Base<T2> { /* ... */ }; // 派生类模板 -
标准模板库（STL）：
-
容器：如
vector、list、map，用于存储和管理数据。vector<int> vec = {1, 2, 3}; for (int val : vec) cout << val << " "; -
算法：如
sort、find，提供通用操作。sort(vec.begin(), vec.end());
应用场景：
-
通用数据结构：如链表、队列等，支持多种数据类型。
-
类型无关算法：如排序、查找，避免重复代码。
三、抽象类与泛型的对比
| 特性 | 抽象类 | 泛型 |
|---|---|---|
| 核心目的 | 定义接口，强制派生类实现逻辑 | 编写类型无关的通用代码 |
| 多态性 | 运行时多态（虚函数） | 编译时多态（模板实例化） |
| 实例化限制 | 不能实例化抽象类 | 模板类/函数在实例化时生成具体代码 |
| 适用场景 | 面向对象设计中的继承与多态 | 需要支持多种数据类型的通用逻辑 |
四、关键总结
-
抽象类：
-
用于定义接口，强制派生类实现特定功能。
-
通过虚函数实现运行时多态，支持基类指针操作派生类对象。
-
-
泛型：
-
通过模板实现代码的通用性，避免重复逻辑。
-
在编译时生成类型相关代码，提高效率和灵活性。
-
-
结合使用：
-
抽象类和泛型可结合使用，例如定义泛型容器时，容器元素类型可以是抽象类的派生类。
-
示例代码：
// 抽象类与泛型结合
template <typename T>
class GenericContainer {
private:vector<T*> items;
public:void addItem(T* item) { items.push_back(item); }void processAll() {for (T* item : items) item->process();}
};class BaseItem { // 抽象类
public:virtual void process() = 0;virtual ~BaseItem() {}
};class DerivedItem : public BaseItem {
public:void process() override { /* ... */ }
};顺序容器
一、顺序容器概览
顺序容器用于存储具有线性关系的元素，支持在任意位置插入、删除和访问元素。C++ STL 中的顺序容器包括：
| 容器 | 特性 | 优点 | 缺点 |
|---|---|---|---|
vector | 动态数组，支持随机访问。 | 快速随机访问（O(1)）。 | 中间插入/删除效率低（O(n)）。 |
deque | 双端队列，支持两端高效操作。 | 两端插入/删除高效（O(1)）。 | 中间操作效率低（O(n)）。 |
list | 双向链表，任意位置插入/删除高效。 | 任意位置操作高效（O(1)）。 | 不支持随机访问（O(n)）。 |
forward_list | 单向链表（C++11），内存占用更小。 | 内存效率高。 | 仅支持单向遍历。 |
array | 固定大小数组（C++11）。 | 栈上分配，性能高。 | 大小不可变。 |
二、核心操作与成员函数
1. 通用操作
-
插入：
push_back、push_front（deque、list）、insert。 -
删除：
pop_back、pop_front（deque、list）、erase。 -
访问：
operator[]、at、front、back。 -
容量管理：
size、resize、capacity、reserve（vector、deque）。
2. 容器特有操作
| 容器 | 特有操作 |
|---|---|
vector | shrink_to_fit（释放多余内存）。 |
deque | push_front、pop_front。 |
list | splice（合并链表）、merge（有序合并）、remove（删除特定值）。 |
forward_list | 仅提供单向迭代器，无 size() 函数。 |
三、性能对比与适用场景
| 场景 | 推荐容器 | 理由 |
|---|---|---|
| 频繁随机访问 | vector、array | 支持 O(1) 随机访问。 |
| 频繁两端操作 | deque | 两端插入/删除高效。 |
| 频繁任意位置插入/删除 | list | 链表结构无需移动元素。 |
| 内存敏感 | forward_list | 内存占用更小。 |
| 固定大小需求 | array | 编译时确定大小，无动态分配开销。 |
四、示例代码要点
1. vector 示例
vector<int> v1(3); // 初始化为3个0
v1.push_back(20); // 末尾添加元素
v1.insert(v1.begin()+2, 2, 30); // 在位置2插入两个30-
注意：
vector扩容时可能触发 2 倍内存分配，可通过reserve预分配空间优化。
2. deque 示例
deque<int> d{1, 2, 3, 4};
d.push_front(200); // 头部插入200
d.push_back(50); // 尾部插入50-
内存分布：由多个连续内存块组成，插入时无需整体复制。
3. list 示例
list<int> l = {7, 5, 16, 8};
l.push_front(25); // 头部插入25
l.remove(5); // 删除所有值为5的元素-
不支持
operator[]，需通过迭代器遍历。
关联容器
一、关联容器概览
关联容器通过平衡二叉树（红黑树）实现，元素按特定规则排序，提供高效的查找（O(log n)）、插入和删除操作。主要包含以下四种容器：
| 容器 | 特性 | 适用场景 |
|---|---|---|
set | 元素唯一，默认升序排列。 | 去重且需要有序访问的场景。 |
multiset | 允许重复元素，默认升序排列。 | 允许重复的有序集合。 |
map | 键值对（key-value），键唯一，按键排序。 | 键唯一且需按键快速查找的映射。 |
multimap | 键可重复，按键排序。 | 一键对应多值的映射。 |
二、核心特性与操作
1. set 与 multiset
-
共同点：
-
底层基于红黑树，元素自动排序。
-
支持插入（
insert）、删除（erase）、查找（find）等操作。
-
-
区别：
-
set元素唯一，multiset允许重复。
-
-
示例代码：
set<int> s{1, 5, 3}; s.insert(2); // 插入元素，自动排序 s.erase(1); // 删除元素multiset<int> ms{1, 1, 3}; ms.insert(1); // 允许重复
2. map与 multimap
-
共同点：
-
存储键值对，按键排序。
-
支持通过键快速查找值（
find、operator[]）。
-
-
区别：
-
map键唯一，multimap键可重复。
-
-
示例代码：
map<string, float> m; m["apple"] = 5.0; // 插入键值对 m.insert({"orange", 2.8});multimap<string, float> mm; mm.insert({"apple", 5.0}); mm.insert({"apple", 8.3}); // 允许重复键
3. 常用操作
-
插入：
s.insert(value); // set/multiset m.insert({key, value}); // map/multimap -
删除：
s.erase(value); // 删除特定值 m.erase(key); // 删除特定键 -
查找：
auto it = s.find(value); // 返回迭代器 auto it = m.find(key); // 返回键对应的迭代器 -
遍历：
for (auto it = s.begin(); it != s.end(); ++it) {cout << *it << endl; // set/multiset } for (auto& [key, val] : m) {cout << key << ":" << val << endl; // map/multimap }
三、关键区别与选择
| 对比项 | set vs multiset | map vs multimap |
|---|---|---|
| 元素唯一性 | set唯一，multiset可重复。 | map键唯一，multimap键可重复。 |
| 查找方式 | 直接按值查找。 | 按键查找值。 |
| 典型应用 | 去重集合、有序数据存储。 | 字典、配置表、多值映射。 |
四、高级操作与技巧
1. multimap 的多值键处理
-
equal_range方法：查找所有匹配键的元素范围。auto range = mm.equal_range("apple"); for (auto it = range.first; it != range.second; ++it) {cout << it->second << endl; // 输出所有"apple"对应的值 }
2. 自定义排序规则
-
通过比较函数模板参数：
set<int, greater<int>> s; // 降序排列 map<string, int, Compare> m; // 自定义键比较规则
3. 性能优化
-
避免频繁插入/删除：红黑树的自平衡操作有开销。
-
使用
emplace替代insert：减少临时对象构造。
五、应用场景与实战
-
去重与排序：
-
使用
set或map自动去重并排序数据。
-
-
频率统计：
-
使用
map<string, int>统计单词频率。
-
-
多值映射：
-
使用
multimap存储学生ID到多个课程成绩的映射。
-
容器适配器、迭代器与函数对象
一、容器适配器
核心概念：
-
定义：基于现有容器封装，提供特定接口（如栈、队列）。
-
类型与底层实现：
-
stack：默认基于deque（支持高效首尾操作）。 -
queue：默认基于deque（避免空间浪费）。 -
priority_queue：默认基于vector（需连续内存构建堆）。
-
-
特性：
-
不直接支持迭代器，仅通过适配接口操作（如
push/pop）。 -
priority_queue默认大根堆，元素按优先级出队。
-
代码示例
queue
#include <iostream>
#include <queue>
using namespace std;
int main(){
queue<int> q;
q.push(17);
q.push(24);
q.push(86);
// 查看队首元素
cout << "queue front:" << q.front() << endl;
// 进行出队操作
while(!q.empty()){
cout << q.front() << endl;
q.pop();
}
return 0;
}stack
#include <iostream>
#include <stack>
using namespace std;
int main(){
stack<int> s;
s.push(17);
s.push(24);
s.push(86);
// 查看栈顶元素
cout << "stack top:" << s.top() << endl;
// 进行出栈操作
while(!s.empty()){
cout << s.top() << endl;
s.pop();
}
return 0;
}priority_queue
#include <iostream>
#include <queue>
using namespace std;
int main()
{priority_queue<int> pq;pq.push(36);pq.push(24);pq.push(86);// 查看队首元素cout << "queue front:" << pq.top() << endl;// 进行出队操作while (!pq.empty()){cout << pq.top() << endl;pq.pop();}二、迭代器
核心概念：
-
作用：提供统一访问容器元素的接口，抽象底层实现（如链表、数组）。
-
实现关键：
-
重载操作符（
++,*,->,==,!=）。 -
begin()返回首元素迭代器，end()返回尾后迭代器。
-
-
分类：
-
输入/输出迭代器、前向/双向/随机访问迭代器（STL容器支持不同类别）。
-
代码示例与修正：
-
自定义链表迭代器：
// 构造函数语法错误修正： iterator(ListNode<T> *ptr) : ptr(ptr) {} // 原代码缺少初始化列表 // 比较操作符修正： bool operator==(const iterator &other) const { return ptr == other.ptr; // 原代码中误写为 other_ptr }
应用场景：
-
泛型编程：STL算法（如
sort,find）通过迭代器操作任意容器。 -
遍历与修改：如
for (auto it = vec.begin(); it != vec.end(); ++it)。
三、函数对象（仿函数）
核心概念：
-
定义：重载
operator()的类实例，可像函数一样调用。 -
优点：
-
状态保存：成员变量记录调用间状态（如计数器）。
-
灵活性：可作为模板参数传递（如STL算法
sort的比较器）。
-
-
STL内建函数对象：
-
算术：
plus<T>,minus<T>。 -
关系：
less<T>,greater<T>。 -
逻辑：
logical_and<T>,logical_not<T>。
-
代码示例与修正：
-
语法错误修正：
class SelfCompare { public:bool operator()(int n1, int n2) { // 原代码缺少括号闭合return n1 > n2;} };
应用场景：
-
STL算法：如
transform使用仿函数对元素批量操作。 -
自定义策略：如排序规则、条件过滤（
find_if）。
对比与联系
| 特性 | 容器适配器 | 迭代器 | 函数对象 |
|---|---|---|---|
| 核心功能 | 封装特定数据结构接口 | 统一容器元素访问方式 | 封装可调用逻辑与状态 |
| 底层依赖 | 基于现有容器（如deque） | 依赖容器内部结构实现 | 独立类或STL内建对象 |
| 典型应用 | 栈、队列、优先队列 | 遍历、算法泛化 | 策略模式、STL算法参数 |
总结
-
容器适配器：通过封装简化特定数据结构操作，隐藏底层细节。
-
迭代器：实现容器与算法的解耦，是泛型编程的基石。
-
函数对象：提供灵活的可调用单元，优于函数指针（支持状态和内联优化）。
综合应用示例：
// 使用 priority_queue（适配器）+ 仿函数（自定义比较规则）
struct Compare {bool operator()(int a, int b) { return a > b; } // 小根堆
};
priority_queue<int, vector<int>, Compare> pq;
- 这是本人的学习笔记不是获利的工具，小作者会一直写下去，希望大家能多多监督我
- 文章会每攒够两篇进行更新发布
- 感谢各位的阅读希望我的文章会对诸君有所帮助