C++初登门槛

多态

一、概念

多态是指不同对象对同一消息产生不同响应的行为。例如，蓝牙、4G、Wi-Fi 对“发送数据”指令有不同的具体实现。

二、核心理解

• 本质：通过基类指针或引用操作子类对象，实现运行时动态绑定。

• 表现形式：

  • 接口统一：基类定义通用接口（如 virtual void TransmitData()）。

  • 实现多样：子类重写接口，提供具体功能（如蓝牙发送数据的具体逻辑）。

三、分类与对比

类型	静态多态（早绑定）	动态多态（晚绑定）
实现方式	函数重载、模板	虚函数（virtual）
绑定时机	编译期确定调用函数	运行时根据对象类型确定调用函数
灵活性	低（依赖编译时类型）	高（支持运行时多态）

四、作用与意义

1. 通用性：将不同子类对象视为基类对象，编写统一代码。

   SendData* devices[] = {new Bluetooth(), new A4G(), new WiFi()};  
   for (auto device : devices) {  device->TransmitData();  // 统一接口，不同实现  
   } 

2. 扩展性：新增子类无需修改现有代码（如新增 ZigBee 模块）。

3. 解耦：分离接口与实现，降低代码依赖性。

五、实现前提条件

1. 继承关系：必须存在基类与子类的继承结构。

2. 虚函数重写：基类方法用 virtual 声明，子类重写该方法。

3. 基类引用/指针指向子类对象：通过基类操作实际子类对象。

六、实现步骤（以物联网设备为例）

1. 定义基类虚函数：

   class SendData {  
   public:  virtual void TransmitData() = 0;  // 纯虚函数  virtual ~SendData() = default;    // 虚析构函数  
   }; 

2. 子类继承并重写虚函数：

   class Bluetooth : public SendData {  
   public:  void TransmitData() override {  cout << "蓝牙发送数据..." << endl;  }  
   }; 

3. 使用基类指针操作子类对象：

   int main() {  SendData* device = new Bluetooth();  device->TransmitData();  // 动态调用 Bluetooth 的实现  delete device;  return 0;  
   }  

七、应用场景示例（物联网设备数据传输）

• 需求：统一管理蓝牙、4G、Wi-Fi 的数据传输接口。

• 设计：

  • 基类 SendData 定义虚函数 TransmitData()。

  • 子类 Bluetooth、A4G、WiFi 分别实现具体传输逻辑。

  • 客户端通过基类指针调用接口，无需关心具体设备类型。

八、注意事项

1. 虚析构函数：基类必须声明虚析构函数，确保正确释放子类资源。

2. 避免切片问题：使用指针或引用传递对象，而非值传递。

3. 纯虚函数：若基类仅定义接口，可声明为纯虚函数（= 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）

1. 核心机制

   • 虚函数表（vtable）：每个包含虚函数的类在编译时生成一个虚函数表，表中存储该类所有虚函数的地址。

   • 虚指针（vptr）：每个对象在内存中隐含一个指向其虚函数表的指针（vptr），用于运行时动态绑定。

2. 内存布局示例

   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 字节。

3. 调试验证（GDB）

   •  调试程序

     gdb a.out

   • 设置断点

     b 函数名/行号

   • 运行调试

     r

   • 单步执行

     n

4. set print object on/off        是否以更易于阅读的方式打印结构体或类对象
5. set print pretty on/off        控制数组打印
6. set print array on        查看对象信息
7. print object        数据显示格式

• x 按十六进制格式显示变量
• d 按照十进制格式显示变量
• u 按十六进制格式显示无符号整型
• o 按八进制格式显示变量
• t 按二进制格式显示变量
• a 按十六进制格式显示变量
• c 按字符格式显示变量
• f 按浮点数格式显示变量

 

虚函数表

• 虚函数表（vtable）是C++中实现多态性的核心机制，它存放了类中虚函数的入口地址。

• _vptr是每个包含虚函数的类的对象中的一个隐藏指针，指向该类的虚函数表。

• 编译器自动生成和维护虚函数表以及_vptr，开发者无需手动干预。

• 在GDB中调试时，可以查看_vptr的值以及它所指向的虚函数表，以了解对象的多态行为。

二、继承与虚函数表覆盖

1. 子类继承父类虚函数表

   • 子类继承父类的虚函数表，若重写父类虚函数，则替换对应条目。

   • 示例：

     class Houyi : public Hero {
     public:virtual void skill() override {}
     };

     • 子类 Houyi 的虚函数表中 skill() 地址指向 Houyi::skill()。

2. 调试验证

   (gdb) print houyi
   $1 = (Houyi) {<Hero> = {_vptr.Hero = 0x56558e7c <vtable for Houyi+8>},looks = 20
   }

三、静态绑定与动态绑定

特性	静态绑定	动态绑定
绑定时机	编译期（根据类型确定调用）	运行期（根据对象实际类型确定）
实现方式	函数重载、模板	虚函数（virtual）
灵活性	低	高

关键区别：

• 动态绑定依赖虚函数表：通过 vptr 找到虚函数表，再根据实际对象类型调用对应函数。

• 多态场景：必须通过基类指针或引用操作子类对象。

四、32位与64位系统下的对象大小

1. 基本规则

   • 指针大小：32位系统4字节，64位系统8字节。

   • 内存对齐：通常按最大成员类型对齐（如 int 按4字节对齐）。

2. 复杂继承示例

   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）

定义：派生类中的成员（函数或属性）与基类同名，导致基类成员在派生类作用域中不可见。
类型：

1. 函数隐藏：

   • 派生类函数与基类函数同名但参数不同，或同名同参数但基类函数非虚。

   • 基类函数被隐藏，需通过作用域解析符（Base::func()）访问。

2. 属性隐藏：

   • 派生类定义与基类同名的成员变量，直接访问时使用派生类版本。

示例：

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）

定义：
        抽象类是一种不能被实例化的类，用于定义接口或基类，要求派生类必须实现其纯虚函数。

核心特点：

1. 纯虚函数：

   • 声明格式为 virtual 返回类型 函数名() = 0;，无函数体。

   • 派生类必须实现所有纯虚函数，否则派生类仍为抽象类。

   class AbstractClass {
   public:virtual void pureVirtual() = 0; // 纯虚函数
   };

2. 不能实例化：

   • 直接实例化抽象类会导致编译错误。

   AbstractClass obj; // 错误：无法创建抽象类对象

3. 基类作用：

   • 抽象类通过指针或引用实现多态，指向派生类对象。

   AbstractClass* ptr = new DerivedClass();
   ptr->pureVirtual(); // 调用派生类的实现

4. 构造与析构函数：

   • 抽象类可以有构造函数和析构函数，但析构函数通常声明为虚函数以确保正确释放资源。

应用场景：

• 定义统一接口：要求所有派生类遵循相同的接口规范。

• 代码复用：基类提供公共逻辑，派生类实现具体功能。

示例：

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）实现类型无关的代码，支持在编译时根据具体类型生成代码。

核心机制：

1. 函数模板：

   • 定义与类型无关的通用函数，支持多种数据类型。

   template <typename T>
   T add(T a, T b) {return a + b;
   }

   • 调用方式：

     • 自动推导：add(3, 4);

     • 显式指定：add<double>(3.14, 2.71);

2. 类模板：

   • 定义与类型无关的类，成员变量和函数的类型由模板参数决定。

   template <typename T>
   class Box {
   private:T content;
   public:Box(T c) : content(c) {}T getContent() { return content; }
   };

3. 模板继承：

   • 派生类继承类模板时，需指定父类的具体类型或自身也声明为模板。

   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());

应用场景：

• 通用数据结构：如链表、队列等，支持多种数据类型。

• 类型无关算法：如排序、查找，避免重复代码。

三、抽象类与泛型的对比

特性	抽象类	泛型
核心目的	定义接口，强制派生类实现逻辑	编写类型无关的通用代码
多态性	运行时多态（虚函数）	编译时多态（模板实例化）
实例化限制	不能实例化抽象类	模板类/函数在实例化时生成具体代码
适用场景	面向对象设计中的继承与多态	需要支持多种数据类型的通用逻辑

四、关键总结

1. 抽象类：

   • 用于定义接口，强制派生类实现特定功能。

   • 通过虚函数实现运行时多态，支持基类指针操作派生类对象。

2. 泛型：

   • 通过模板实现代码的通用性，避免重复逻辑。

   • 在编译时生成类型相关代码，提高效率和灵活性。

3. 结合使用：

   • 抽象类和泛型可结合使用，例如定义泛型容器时，容器元素类型可以是抽象类的派生类。

示例代码：

// 抽象类与泛型结合
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：减少临时对象构造。

五、应用场景与实战

1. 去重与排序：

   • 使用 set 或 map 自动去重并排序数据。

2. 频率统计：

   • 使用 map<string, int> 统计单词频率。

3. 多值映射：

   • 使用multimap存储学生ID到多个课程成绩的映射。

容器适配器、迭代器与函数对象

一、容器适配器

核心概念：

1. 定义：基于现有容器封装，提供特定接口（如栈、队列）。

2. 类型与底层实现：

   • stack：默认基于 deque（支持高效首尾操作）。

   • queue：默认基于 deque（避免空间浪费）。

   • priority_queue：默认基于 vector（需连续内存构建堆）。

3. 特性：

   • 不直接支持迭代器，仅通过适配接口操作（如 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();}

二、迭代器

核心概念：

1. 作用：提供统一访问容器元素的接口，抽象底层实现（如链表、数组）。

2. 实现关键：

   • 重载操作符（++, *, ->, ==, !=）。

   • begin() 返回首元素迭代器，end() 返回尾后迭代器。

3. 分类：

   • 输入/输出迭代器、前向/双向/随机访问迭代器（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)。

三、函数对象（仿函数）

核心概念：

1. 定义：重载 operator() 的类实例，可像函数一样调用。

2. 优点：

   • 状态保存：成员变量记录调用间状态（如计数器）。

   • 灵活性：可作为模板参数传递（如STL算法 sort 的比较器）。

3. 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算法参数

总结

1. 容器适配器：通过封装简化特定数据结构操作，隐藏底层细节。

2. 迭代器：实现容器与算法的解耦，是泛型编程的基石。

3. 函数对象：提供灵活的可调用单元，优于函数指针（支持状态和内联优化）。

综合应用示例：

// 使用 priority_queue（适配器）+ 仿函数（自定义比较规则）
struct Compare {bool operator()(int a, int b) { return a > b; }  // 小根堆
};
priority_queue<int, vector<int>, Compare> pq;

• 这是本人的学习笔记不是获利的工具，小作者会一直写下去，希望大家能多多监督我
• 文章会每攒够两篇进行更新发布
• 感谢各位的阅读希望我的文章会对诸君有所帮助