《C++队列通讲：从基础到进阶的全面解析》

引言：队列的计算机科学意义

在数据结构与算法领域，队列作为最基础的线性结构之一，其FIFO特性使其成为解决顺序依赖问题的关键工具。从操作系统进程调度到网络数据包处理，从BFS算法到任务流水线设计，队列的抽象思维贯穿计算机系统各层级。掌握队列的实现原理与优化技巧，是理解高效系统设计的必经之路。本文将从基础实现到并发扩展，全方位解析C++队列的技术脉络。

一、队列基础概念与特性

队列（Queue）是一种先进先出（FIFO）的线性数据结构，其核心特性包括：

有序性：元素按插入顺序排列，最早进入的元素优先被移除

受限操作集：仅支持队尾插入（enqueue）和队首移除（dequeue）

典型场景：任务调度、缓冲区管理、广度优先搜索等

二、C++队列的三种实现方式

2.1 数组模拟队列

通过动态数组实现，需处理队满扩容和队空判断：

 

template<typename T>   class ArrayQueue {   
private:       T* arr;       
int front, rear, capacity;   
public:       // 构造函数与析构函数       
void enqueue(T value) {           
if (rear == capacity) resize();   
        arr[rear++] = value; 
      }       
T dequeue() {           
if (front == rear) throw underflow;           
return arr[front++];       }   
};  

2.2 链表实现队列

利用指针动态分配节点，避免扩容开销：

template<typename T>   
class LinkedQueue {   private:       
struct Node {           T data;           
Node* next;      
 };      
 Node* head, tail;  
 public:       
void enqueue(T value) 
{           
Node* newNode = new Node{value};  
         if (tail == nullptr) {               
head = tail = newNode;           
} else {               
tail->next = newNode;            
   tail = newNode;          
 }       }   };  

 

2.3 标准库队列

<queue>提供现成实现，支持多种容器适配器：

#include <queue>   
std::queue<int> q;   
q.push(1); // 入队   
int val = q.front(); // 访问队首 
  q.pop(); // 出队

   

三、标准库的高级应用

3.1 优先级队列

<queue>与<functional>结合实现：

#include <queue>  

#include <functional>  

std::priority_queue<int, std::vector<int>, std::greater<int>> pq;  

pq.push(3);  

pq.push(1); // 自动按升序排列   

3.2 双端队列

<deque>实现双向队列：

std::deque<int> dq;  

dq.push_front(1); // 头部插入  

dq.push_back(2); // 尾部插入 

  

四、进阶主题与性能优化

4.1 循环队列技巧

通过模运算实现高效循环：

int front = 0, rear = 0;   
int size = 10;   
int* arr = new int[size];   
void enqueue(int val) {      
 arr[rear++ % size] = val;   
}   

4.2 并发队列

C++11原子操作实现线程安全队列：

#include <atomic>   
std::atomic<int> front(0);   
std::queue<int> q;   
void producer() {   
    q.push(1);       
    front++;   
}   
void consumer() {       
while (front.load() <= 0)
 {
int val = q.front();       q.pop();       front--;   } 
}         

4.3 阻塞队列

结合条件变量实现生产者-消费者模型：

#include <mutex>  

#include <condition_variable>

  std::mutex mtx;   std::condition_variable cv;  

std::queue<int> q;   void producer(int val) {    

  std::unique_lock<std::mutex> lock(mtx);      

q.push(val);      

cv.notify_one();  

}   void consumer() {      

std::unique_lock<std::mutex> lock(mtx);    

  cv.wait(lock, []{return !q.empty();});      

int val = q.front();      

q.pop();   }