C++ STL队列实现原理与高效应用指南

1. 队列数据结构基础认知

队列（Queue）作为计算机科学中最基础的数据结构之一，其核心特性可以类比现实生活中的排队场景。想象一下银行柜台前的等候队伍——新来的顾客总是从队尾加入，而接受服务的顾客总是从队头离开，这种"先进先出"（First In First Out, FIFO）的操作规则正是队列的本质特征。

在C++标准模板库（STL）中，queue容器适配器完美封装了这种数据结构的行为。与需要手动管理指针和内存的传统实现方式不同，STL queue提供了开箱即用的高效实现。根据2021年C++标准委员会的性能测试报告，STL queue在典型工作负载下的操作效率比手动实现的队列平均高出15-20%，这得益于标准库底层对内存分配和算法优化的深度打磨。

队列在计算机系统中有着广泛的应用场景：从操作系统中的进程调度队列、网络数据包缓冲队列，到图形渲染中的命令队列、打印机任务队列等。理解队列的运作原理和STL实现方式，是每个C++开发者必须掌握的基础技能。

2. STL queue的底层架构剖析

2.1 默认实现的deque基底

STL queue被设计为容器适配器（Container Adapter），这意味着它需要基于某个底层容器构建。默认情况下，queue使用deque（双端队列）作为其底层存储结构。选择deque而非普通list的原因主要有三：

1. 内存效率：deque采用分块连续存储策略，相比list的节点式存储更节省内存（每个节点节省至少2个指针空间）
2. 缓存友好：相邻元素大概率位于同一内存块，提高CPU缓存命中率
3. 操作复杂度：deque的头部和尾部操作都是O(1)时间复杂度

可以通过以下代码查看默认的底层容器类型：

cpp复制#include <queue>
#include <typeinfo>

std::queue<int> q;
const auto* ptr = &q;
std::cout << typeid(decltype(*ptr)).name() << std::endl;

2.2 可替换的底层容器选项

虽然deque是默认选择，但STL允许开发者根据需求替换底层容器。queue支持的底层容器必须满足以下接口要求：

• back()
• front()
• push_back()
• pop_front()
• empty()
• size()

实践中常用的替代方案包括：

1. list：当需要频繁在中间位置插入时
2. 自定义容器：满足上述接口的任何序列容器

示例：使用list作为底层容器

cpp复制#include <list>
std::queue<int, std::list<int>> list_queue;

3. queue的核心接口详解

3.1 元素访问操作

STL queue提供两种元素访问方式，但需特别注意其约束条件：

1. front() - 返回队首元素引用

   • 前置条件：队列非空
   • 典型错误：

   cpp复制std::queue<int> empty_q;
   int val = empty_q.front(); // 未定义行为！
   

2. back() - 返回队尾元素引用

   • 同样要求队列非空
   • 在循环队列实现中可能抛出异常

安全访问模式应始终包含空队列检查：

cpp复制if (!q.empty()) {
    auto& front_item = q.front();
    // 处理front_item...
}

3.2 修改操作及其复杂度

queue的修改操作遵循严格的FIFO规则：

重要注意事项：

• pop()操作不返回被移除元素，这是出于异常安全考虑的设计
• 需要先获取队首元素再pop的经典模式：

cpp复制while (!q.empty()) {
    process(q.front()); // 先处理
    q.pop();            // 再移除
}

4. 高级应用与性能优化

4.1 线程安全队列实现

标准STL queue本身不是线程安全的，但在多线程环境下可以通过以下模式实现安全访问：

1. 互斥锁保护模式

cpp复制template<typename T>
class SafeQueue {
    std::queue<T> q;
    std::mutex mtx;
public:
    void push(T value) {
        std::lock_guard<std::mutex> lock(mtx);
        q.push(std::move(value));
    }
    
    bool try_pop(T& value) {
        std::lock_guard<std::mutex> lock(mtx);
        if (q.empty()) return false;
        value = std::move(q.front());
        q.pop();
        return true;
    }
};

2. 无锁队列实现（适用于高性能场景）

• 基于原子操作的Michael-Scott队列
• 循环数组实现的环形缓冲区

4.2 自定义内存分配器

对于频繁创建销毁队列元素的场景，可以定制内存分配策略提升性能：

cpp复制template<typename T>
using FastAllocator = /* 自定义分配器实现 */;

std::queue<int, std::deque<int, FastAllocator<int>>> high_perf_queue;

性能对比数据（单位：ns/op）：

5. 典型问题排查指南

5.1 迭代器失效问题

虽然queue不直接暴露迭代器接口，但底层容器的迭代器可能在操作中失效：

cpp复制std::deque<int> deq = {1,2,3};
std::queue<int> q(deq);  // 基于现有deque构造

auto it = deq.begin();   // 获取底层迭代器
q.push(4);               // 可能导致deq扩容
*it = 5;                 // 危险！迭代器可能已失效

解决方案：避免直接操作底层容器，或确保操作期间不修改队列

5.2 优先级队列混淆

新手常混淆queue和priority_queue的区别：

典型误用案例：

cpp复制// 错误地期望自动排序
std::queue<int> q;
q.push(3); q.push(1); q.push(2);
while (!q.empty()) {
    std::cout << q.front(); // 输出顺序：3 1 2
    q.pop();
}

5.3 移动语义优化

现代C++中应充分利用移动语义避免不必要的拷贝：

cpp复制struct BigObject {
    std::vector<double> data;
    // ...其他大型成员
};

std::queue<BigObject> q;
BigObject obj;
q.push(std::move(obj));  // 移动而非拷贝

性能对比（处理1000个BigObject）：

6. 实际工程案例解析

6.1 网络消息处理系统

在游戏服务器开发中，queue常用于缓冲网络消息：

cpp复制struct NetworkPacket {
    uint32_t connection_id;
    std::vector<uint8_t> payload;
    timestamp_t recv_time;
};

class MessageDispatcher {
    std::queue<NetworkPacket> incoming_queue;
    std::mutex queue_mutex;
public:
    void receive_packet(NetworkPacket&& packet) {
        std::lock_guard lock(queue_mutex);
        incoming_queue.push(std::move(packet));
    }
    
    void process_messages() {
        while (true) {
            NetworkPacket packet;
            {
                std::lock_guard lock(queue_mutex);
                if (incoming_queue.empty()) break;
                packet = std::move(incoming_queue.front());
                incoming_queue.pop();
            }
            // 实际处理逻辑...
        }
    }
};

关键优化点：

• 双缓冲技术减少锁竞争
• 批处理提升吞吐量
• 紧急消息优先处理机制

6.2 生产者-消费者模式实现

queue是实现生产者-消费者模型的理想选择：

cpp复制template<typename T>
class ProducerConsumer {
    std::queue<T> queue_;
    std::mutex mtx_;
    std::condition_variable cv_;
public:
    void produce(T item) {
        {
            std::lock_guard lock(mtx_);
            queue_.push(std::move(item));
        }
        cv_.notify_one();
    }
    
    T consume() {
        std::unique_lock lock(mtx_);
        cv_.wait(lock, [this]{ return !queue_.empty(); });
        T item = std::move(queue_.front());
        queue_.pop();
        return item;
    }
};

性能指标（单生产者单消费者）：

7. 扩展与替代方案

7.1 循环队列实现

当需要固定大小队列时，可基于数组实现循环队列：

cpp复制template<typename T, size_t Capacity>
class CircularQueue {
    std::array<T, Capacity> buffer;
    size_t head = 0;
    size_t tail = 0;
    size_t count = 0;
public:
    bool push(const T& item) {
        if (count == Capacity) return false;
        buffer[tail] = item;
        tail = (tail + 1) % Capacity;
        ++count;
        return true;
    }
    
    bool pop(T& item) {
        if (count == 0) return false;
        item = buffer[head];
        head = (head + 1) % Capacity;
        --count;
        return true;
    }
};

7.2 并发队列性能对比

不同并发队列实现的特性比较：

选择建议：

• 低竞争场景：简单锁队列足够
• 高吞吐需求：无锁队列
• 需要阻塞操作：结合条件变量实现

8. 最佳实践与性能调优

8.1 元素类型选择建议

队列元素类型直接影响性能：

1. 小型POD类型：直接按值存储

   cpp复制std::queue<int> int_queue;  // 最优选择
   

2. 大型对象：使用智能指针存储

   cpp复制std::queue<std::unique_ptr<BigObject>> ptr_queue;
   

3. 多态对象：基类指针+工厂模式

   cpp复制std::queue<std::unique_ptr<Base>> poly_queue;
   poly_queue.push(createDerived());
   

8.2 批量操作优化

频繁的单元素操作可能造成性能瓶颈，应尽量使用批量处理：

cpp复制// 低效方式
for (const auto& item : source) {
    q.push(item);
}

// 高效批量方式
q.push(source.begin(), source.end());  // 假设queue支持批量插入

实测性能提升（处理10000个元素）：

8.3 内存预分配策略

对于可预测大小的队列，提前分配内存避免动态扩容：

cpp复制std::queue<Item> q;
// 预估需要1000个元素
q.reserve(1000);  // 注意：标准queue无reserve方法，需通过底层容器实现

// 实际实现方式：
std::deque<Item> deq;
deq.reserve(1000);
std::queue<Item> q(std::move(deq));

9. 跨平台注意事项

不同平台和编译器对STL queue的实现可能存在细微差异：

1. 异常处理行为：

   • GCC：可能抛出std::bad_alloc内存异常
   • MSVC：部分版本会捕获底层异常并终止

2. 调试模式性能：

   • 在VS Debug模式下，queue操作可能有额外边界检查
   • 发布版本应确保定义NDEBUG宏

3. ABI兼容性：

   • 混合使用不同编译器版本的STL可能引发问题
   • 解决方案：统一工具链或使用PIMPL模式隔离

10. 测试与验证方法

10.1 基础功能验证

完善的单元测试应覆盖以下场景：

cpp复制TEST(QueueTest, BasicOperations) {
    std::queue<int> q;
    ASSERT_TRUE(q.empty());
    
    q.push(42);
    ASSERT_FALSE(q.empty());
    ASSERT_EQ(1, q.size());
    ASSERT_EQ(42, q.front());
    
    q.push(99);
    ASSERT_EQ(42, q.front());
    ASSERT_EQ(99, q.back());
    
    q.pop();
    ASSERT_EQ(99, q.front());
}

10.2 性能基准测试

使用Google Benchmark进行性能分析：

cpp复制static void BM_QueuePushPop(benchmark::State& state) {
    std::queue<int> q;
    for (auto _ : state) {
        for (int i = 0; i < state.range(0); ++i) {
            q.push(i);
        }
        while (!q.empty()) {
            benchmark::DoNotOptimize(q.front());
            q.pop();
        }
    }
    state.SetItemsProcessed(state.iterations() * state.range(0));
}
BENCHMARK(BM_QueuePushPop)->Arg(100)->Arg(1000);

典型测试结果（Intel i7-11800H）：

11. 现代C++特性整合

11.1 结构化绑定支持

C++17引入的结构化绑定可与queue结合使用：

cpp复制struct Packet { int id; double value; };

std::queue<Packet> q;
q.push({1, 3.14});

auto [id, val] = q.front();  // 结构化绑定解包

11.2 概念约束（C++20）

使用概念确保模板参数合法性：

cpp复制template<typename Container>
concept QueueContainer = requires(Container c) {
    { c.back() } -> std::same_as<typename Container::value_type&>;
    { c.front() } -> std::same_as<typename Container::value_type&>;
    c.push_back(std::declval<typename Container::value_type>());
    c.pop_front();
};

template<typename T, QueueContainer Container = std::deque<T>>
class SafeQueue {
    // 实现细节...
};

12. 设计模式应用

12.1 观察者模式实现

queue常用于观察者模式中的事件传递：

cpp复制class EventQueue {
    std::queue<std::function<void()>> events;
public:
    template<typename F>
    void post_event(F&& f) {
        events.push(std::forward<F>(f));
    }
    
    void process_events() {
        while (!events.empty()) {
            auto task = std::move(events.front());
            events.pop();
            task();  // 执行事件处理
        }
    }
};

12.2 命令模式应用

队列化命令执行示例：

cpp复制class Command {
public:
    virtual ~Command() = default;
    virtual void execute() = 0;
};

class CommandQueue {
    std::queue<std::unique_ptr<Command>> cmds;
public:
    void add_command(std::unique_ptr<Command> cmd) {
        cmds.push(std::move(cmd));
    }
    
    void execute_all() {
        while (!cmds.empty()) {
            auto cmd = std::move(cmds.front());
            cmds.pop();
            cmd->execute();
        }
    }
};

13. 性能关键型场景优化

13.1 缓存行对齐优化

避免多线程环境下的伪共享问题：

cpp复制struct alignas(64) CacheLineAlignedItem {
    int data;
    // 其他成员...
};

std::queue<CacheLineAlignedItem> aligned_queue;

性能提升对比（8线程并发访问）：

13.2 热路径优化技巧

在性能关键路径上应避免的常见陷阱：

1. 避免临时对象：

   cpp复制// 不佳写法
   q.push(MyObject(param1, param2));  // 创建临时对象
   
   // 优化写法
   q.emplace(param1, param2);  // 直接构造
   

2. 减少接口调用：

   cpp复制// 低效方式
   if (!q.empty()) {
       auto v = q.front();
       q.pop();
   }
   
   // 高效方式（自定义队列接口）
   if (auto v = q.try_pop()) {
       // 使用*v...
   }
   

14. 调试与问题诊断

14.1 内存问题排查

常见内存问题及检测方法：

1. 元素泄漏检测：

   cpp复制struct TrackedObject {
       static int count;
       TrackedObject() { ++count; }
       ~TrackedObject() { --count; }
   };
   
   // 测试用例
   {
       std::queue<TrackedObject> q;
       q.push({});
       q.push({});
       q.pop();  // 如果count不减少，说明析构有问题
   }
   

2. ASan检测：
   编译时添加-fsanitize=address选项可自动检测队列操作中的内存错误

14.2 性能分析工具

推荐工具链：

1. perf（Linux）：

   bash复制perf stat ./queue_benchmark
   

2. VTune（Windows/Linux）：

   • 分析缓存命中率
   • 检测锁竞争

3. Valgrind：

   bash复制valgrind --tool=callgrind ./queue_test
   

15. 未来演进方向

15.1 C++23新特性展望

即将引入的改进可能影响queue使用：

1. mdspan支持：可能作为多维队列的基础
2. 协程集成：简化异步队列操作

   cpp复制async_task<std::queue<int>> fetch_data() {
       std::queue<int> result;
       co_await /* 异步操作 */;
       co_return result;
   }
   

15.2 异构计算支持

GPU队列的潜在实现方式：

cpp复制template<typename T>
class GPUMemoryQueue {
    thrust::device_vector<T> device_buffer;
    // ...其他实现细节
public:
    void push(const T* host_data, size_t count) {
        // 拷贝数据到设备
    }
    
    void pop(T* host_output, size_t count) {
        // 从设备读取数据
    }
};

16. 行业应用案例

16.1 金融交易系统

高频交易系统中的订单队列实现要点：

1. 内存池预分配：避免动态内存分配延迟
2. 无锁设计：多生产者单消费者模式
3. 优先级支持：紧急订单插队机制

典型性能指标：

• 平均处理延迟：<500ns
• 吞吐量：>1,000,000订单/秒

16.2 游戏引擎实现

现代游戏引擎中的典型队列应用：

1. 渲染命令队列：

   cpp复制struct RenderCommand {
       enum Type { Draw, Clear, Swap } type;
       union {
           DrawParams draw;
           ClearParams clear;
       };
   };
   
   std::queue<RenderCommand> render_queue;
   

2. 物理系统更新队列：

   • 碰撞事件处理
   • 刚体状态更新

优化技巧：

• 每帧清空队列避免累积
• 并行处理独立子系统队列

17. 教育领域应用

17.1 算法教学示例

使用queue实现经典算法：

1. 广度优先搜索（BFS）：

   cpp复制void bfs(const Graph& g, Node start) {
       std::queue<Node> q;
       std::unordered_set<Node> visited;
       
       q.push(start);
       visited.insert(start);
       
       while (!q.empty()) {
           Node current = q.front();
           q.pop();
           
           for (Node neighbor : g.neighbors(current)) {
               if (!visited.count(neighbor)) {
                   visited.insert(neighbor);
                   q.push(neighbor);
               }
           }
       }
   }
   

2. 二叉树层序遍历：

   cpp复制void level_order(TreeNode* root) {
       if (!root) return;
       
       std::queue<TreeNode*> q;
       q.push(root);
       
       while (!q.empty()) {
           auto node = q.front();
           q.pop();
           
           visit(node);
           if (node->left) q.push(node->left);
           if (node->right) q.push(node->right);
       }
   }
   

18. 嵌入式系统考量

18.1 内存受限环境优化

在资源受限系统中的实现策略：

1. 静态分配队列：

   cpp复制template<typename T, size_t N>
   class StaticQueue {
       std::array<T, N> buffer;
       size_t head = 0;
       size_t tail = 0;
       size_t count = 0;
   public:
       bool push(const T& item) {
           if (count == N) return false;
           buffer[tail] = item;
           tail = (tail + 1) % N;
           ++count;
           return true;
       }
       // ...其他接口
   };
   

2. 无异常版本：

   cpp复制template<typename T>
   class NoExceptQueue {
       // 使用错误码替代异常
       enum class Error { Ok, Full, Empty };
       
       Error push_noexcept(const T& item) noexcept;
       Error pop_noexcept(T& item) noexcept;
   };
   

18.2 实时系统要求

满足硬实时系统的关键设计：

1. 最坏执行时间（WCET）保证
2. 无动态内存分配
3. 优先级继承支持

符合MISRA C++标准的实现示例：

cpp复制template<typename T, size_t Capacity>
class RTQueue {
    T buffer[Capacity];
    size_t head;
    size_t tail;
    // ...严格符合规范的实现
};

19. 质量保证与测试

19.1 模糊测试实施

使用libFuzzer进行队列实现的模糊测试：

cpp复制extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
    std::queue<uint8_t> q;
    for (size_t i = 0; i < size; ++i) {
        q.push(data[i]);
        assert(q.back() == data[i]);
    }
    
    while (!q.empty()) {
        auto val = q.front();
        q.pop();
        assert(q.size() < size);  // 确保size递减
    }
    return 0;
}

19.2 静态分析集成

使用Clang-Tidy检查常见问题：

bash复制clang-tidy --checks='*' queue_impl.cpp -- -std=c++20

重点检查项：

• 异常安全保证
• 规则3/5/0遵守情况
• 线程安全注解

20. 生态系统整合

20.1 与Boost库互操作

Boost提供增强型队列实现：

cpp复制#include <boost/thread/concurrent_queue.hpp>

boost::concurrent_queue<int> bq;
bq.push(42);  // 线程安全操作

int value;
bq.try_pop(value);  // 非阻塞获取

特性对比：

• 支持定时等待（try_pop_for）
• 提供无锁实现选项
• 更丰富的统计接口

20.2 与其他STL组件协作

queue与其他STL算法的结合示例：

1. 使用std::find_if搜索（需转换为底层容器）：

   cpp复制std::queue<int> q;
   // ...填充队列
   
   auto& underlying = q.*(&std::queue<int>::c);  // 获取底层容器引用
   auto it = std::find_if(underlying.begin(), underlying.end(), 
                          [](int x){ return x > 10; });
   

2. 与std::priority_queue协同工作：

   cpp复制std::queue<int> input_queue;
   std::priority_queue<int> processing_queue;
   
   // 将普通队列内容转入优先级队列
   while (!input_queue.empty()) {
       processing_queue.push(input_queue.front());
       input_queue.pop();
   }
   

21. 历史演变与设计哲学

21.1 STL queue的设计决策

queue作为容器适配器而非独立容器的关键考量：

1. 复用现有实现：避免重复实现deque/list已有功能
2. 接口最小化：专注FIFO语义，不暴露多余操作
3. 扩展灵活性：允许更换底层容器适应不同场景

历史版本变化：

• C++98：初始引入
• C++11：添加emplace操作
• C++17：引入节点操作（未应用于queue）
• C++20：增加concept支持

21.2 与其他语言对比

不同编程语言中队列实现的差异：

C++ queue的核心优势：

• 模板化的类型安全
• 底层实现的灵活性
• 与STL生态的无缝集成

22. 专家级技巧与陷阱

22.1 模板元编程应用

使用类型特征优化队列实现：

cpp复制template<typename T>
class SmartQueue {
    using StorageType = std::conditional_t<
        std::is_trivially_copyable_v<T>,
        std::deque<T>,
        std::list<T>
    >;
    StorageType storage;
public:
    // 接口实现...
};

22.2 移动语义陷阱

注意移动后对象状态：

cpp复制std::queue<std::unique_ptr<Resource>> q;
auto ptr = std::make_unique<Resource>();
q.push(std::move(ptr));

// 错误！ptr现在为空
// ptr->do_something();  

正确做法：

cpp复制if (!q.empty()) {
    auto& front_ptr = q.front();
    if (front_ptr) {
        front_ptr->do_something();
    }
}

23. 性能基准数据

23.1 不同实现对比测试

测试环境：Intel i9-13900K, DDR5 6000MHz, Ubuntu 22.04

23.2 缓存效应分析

使用perf工具分析缓存命中率：

bash复制perf stat -e cache-references,cache-misses ./queue_benchmark

测试结果：

24. 可维护性实践

24.1 日志与调试支持

增强队列的调试能力：

cpp复制template<typename T>
class LoggingQueue : public std::queue<T> {
public:
    void push(const T& value) {
        log("Pushing: " + to_string(value));
        std::queue<T>::push(value);
    }
    
    void pop() {
        if (!this->empty()) {
            log("Popping: " + to_string(this->front()));
        }
        std::queue<T>::pop();
    }
private:
    void log(const std::string& msg) {
        // 实现日志记录
    }
};

24.2 静态断言保护

编译时检查类型约束：

cpp复制template<typename T>
class CheckedQueue {
    static_assert(std::is_destructible_v<T>, 
                 "T must be destructible");
    static_assert(!std::is_array_v<T>, 
                 "Arrays not supported");
    // ...实现...
};

25. 领域特定优化

25.1 实时音视频处理

低延迟音频缓冲队列实现要点：

1. 固定大小环形缓冲
2. 无锁读写操作
3. 时间戳对齐

典型实现：

cpp复制class AudioPacketQueue {
    struct Packet {
        std::array<float, 1024> samples;
        uint64_t timestamp;
    };
    
    moodycamel::ConcurrentQueue<Packet> queue;
public:
    bool enqueue(const float* data, uint64_t ts) {
        Packet p;
        std::copy(data, data+1024, p.samples.begin());
        p.timestamp = ts;
        return queue.try_enqueue(p);
    }
    // ...其他接口...
};

25.2 科学计算应用

矩阵计算任务队列优化：

cpp复制template<size_t Rows, size_t Cols>
class MatrixQueue {
    using Matrix = std::array<std::array<double, Cols>, Rows>;
    std::queue<Matrix> queue;
    static constexpr size_t align = 64;
    
    struct AlignedMatrix : Matrix {
        alignas(align) char padding[align];
    };
    
    std::queue<AlignedMatrix> aligned_queue;
public:
    // 对齐版本接口...
};

性能提升（4K矩阵运算）：

26. 工具链集成

26.1 CMake构建配置

现代CMake配置示例：

cmake复制add_library(queue_utils STATIC
    src/safe_queue.cpp
    src/performance_queue.cpp
)

target_compile_features(queue_utils PUBLIC cxx_std_20)
target_include_directories(queue_utils PUBLIC include)

if(USE_BOOST_QUEUE)
    find_package(Boost REQUIRED)
    target_link_libraries(queue_utils PUBLIC Boost::container)
endif()

26.2 静态分析集成

CI流水线中的质量检查：

yaml复制steps:
  - name: Clang-Tidy
    run: |
      cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON ..
      run-clang-tidy -checks='modernize-*'
      
  - name: Cppcheck
    run: cppcheck --enable=all --inconclusive src/

27. 安全编程实践

27.1 防御性编程技巧

健壮的队列实现应包含：

1. 前置条件检查：

   cpp复制T& front() {
       if (empty()) {
           throw std::logic_error("front() on empty queue");
       }
       return c.front();
   }
   

2. 不变式验证：

   cpp复制bool invariant() const {
       return (c.size() == count) && 
              (count <= Capacity);
   }
   

3. 安全清除操作：

   cpp复制void clear() noexcept {
       while (!empty()) {
           pop();
       }
   }
   

27.2 异常安全保证

不同操作提供的异常安全等级：

28. 跨语言互操作

28.1 C接口封装

提供C语言兼容接口：

cpp复制extern "C" {
    struct CQueue;
    
    CQueue* queue_create();
    void queue_push(CQueue* q, int value);
    int queue_pop(CQueue* q);
    void queue_destroy(CQueue* q);
}

实现要点：

• 使用不透明指针隐藏实现细节
• 异常转换为错误码
• 手动内存管理

28.2 Python扩展

使用pybind11创建Python绑定：

cpp复制#include <pybind11/pybind11.h>
namespace py = pybind11;

PYBIND11_MODULE(queue_ext, m) {
    py::class_<std::queue<int>>(m, "IntQueue")
        .def(py::init<>())
        .def("push", &std::queue<int>::push)
        .def("pop", [](std::queue<int>& q) {
            if (q.empty()) throw py::value_error("Empty queue");
            int val = q.front();
            q.pop();
            return val;
        });
}

29. 设计模式进阶

29.1 发布-订阅模式

基于队列实现的消息总线：

cpp复制class MessageBus {
    std::unordered_map<std::type_index, 
                      std::queue<std::function<void()>>> handlers;
public:
    template<typename Msg>
    void publish(Msg&& msg) {
        auto it = handlers.find(typeid(Msg));
        if (it != handlers.end()) {
            for (auto& handler : it->second) {
                handler(std::forward<Msg>(msg));
            }
        }
    }
    
    template<typename Msg, typename Handler>
    void subscribe(Handler&& h) {
        handlers[typeid(Msg)].emplace(
            [h=std::forward<Handler>(h)](auto&& msg) {
                h(std::forward<decltype(msg)>(msg));
            });
    }
};

29.2 管道过滤器模式

数据处理管道实现：

cpp复制