C++泛型队列实现遇特定问题，附相关代码片段

嘿，我看你在写泛型队列的时候碰到卡壳了，盯着你的代码片段看了下，发现几个关键问题，咱们一个个捋清楚：

1. 默认构造函数的调用错误 #

你写的默认构造函数是这么写的：

Queue(){ Queue(SOME_PREDEFINED_CONSTANT); }

这可不行！这里只是在默认构造函数里创建了一个临时的Queue对象，创建完就立刻销毁了，根本没给当前对象的成员变量做初始化——相当于默认构造出来的队列，queue指针是野指针，front、back、MAX_SIZE都是乱值。

解决办法分两种：

• 如果你用的是C++11及以后的标准，直接用委托构造函数，让默认构造调用带参构造：

  Queue() : Queue(SOME_PREDEFINED_CONSTANT) {}
  

• 要是还在用旧标准，就手动初始化所有成员：

  Queue(){
      MAX_SIZE = SOME_PREDEFINED_CONSTANT;
      queue = new T[MAX_SIZE];
      front = 0;
      back = 0;
      cout << "inside default constructor:" << " back= " << back << " front=" << front << endl;
  }
  

2. 队列满/空的判断逻辑有漏洞 #

你现在用back < MAX_SIZE作为push的条件，这会导致一个问题：当你pop几个元素后，front指针往前移了，但back已经走到MAX_SIZE了，明明队列里有空位，却没法再push了——这是典型的“假满”。

通常环形队列（循环队列）的正确判断方式是预留一个空位：

• 队列空：front == back
• 队列满：(back + 1) % MAX_SIZE == front

基于这个逻辑，修改你的push函数：

void push(const T entry){
    // 先检查队列是否已满
    if((back + 1) % MAX_SIZE != front){
        queue[back] = entry;
        back = (back + 1) % MAX_SIZE; // 循环移动back指针
        cout << "Pushed entry, back now: " << back << endl;
    } else {
        cout << "Queue is full! Can't push new elements." << endl;
    }
}

对应的pop函数也要同步调整，确保能正确循环：

T pop(){
    if(front != back){ // 检查队列非空
        T val = queue[front];
        front = (front + 1) % MAX_SIZE;
        return val;
    } else {
        cout << "Queue is empty! Can't pop elements." << endl;
        // 这里可以选择抛出异常，或者返回T的默认构造值，按需处理
        return T();
    }
}

3. 内存泄漏与拷贝安全问题 #

你现在的类没有析构函数，当Queue对象被销毁时，用new T[MAX_SIZE]分配的数组内存不会被释放，妥妥的内存泄漏。必须加一个析构函数：

~Queue(){
    delete[] queue; // 注意释放数组要用delete[]，不能用delete
}

另外，C++默认的拷贝构造和赋值运算符是浅拷贝，如果把一个Queue对象赋值给另一个，两个对象会共用同一块数组内存，销毁时会重复释放内存导致崩溃。所以必须手动实现深拷贝：

// 拷贝构造函数
Queue(const Queue& other){
    MAX_SIZE = other.MAX_SIZE;
    front = other.front;
    back = other.back;
    queue = new T[MAX_SIZE];
    // 逐个复制队列里的元素
    for(int i = front; i != back; i = (i + 1) % MAX_SIZE){
        queue[i] = other.queue[i];
    }
}

// 赋值运算符重载
Queue& operator=(const Queue& other){
    if(this != &other){ // 防止自赋值导致的内存泄漏
        delete[] queue; // 先释放当前对象的旧内存
        MAX_SIZE = other.MAX_SIZE;
        front = other.front;
        back = other.back;
        queue = new T[MAX_SIZE];
        for(int i = front; i != back; i = (i + 1) % MAX_SIZE){
            queue[i] = other.queue[i];
        }
    }
    return *this;
}

我在尝试实现C++泛型队列时遇到了一个非常具体的问题，以下是相关代码：

template <class T> class Queue { 
private: 
    T * queue; 
    int front; 
    int back; 
    int MAX_SIZE; 
public: 
    Queue(){ Queue(SOME_PREDEFINED_CONSTANT); } 
    Queue(int size){ 
        queue = new T[size]; 
        MAX_SIZE = size; 
        front = 0; 
        back = 0; 
        cout << "inside constructor:" << " back= " << back << " front=" << front << endl; 
    } 
    void push(const T entry){ 
        if(back < MAX_SIZE){ 
            queue...

内容的提问来源于stack exchange，提问作者Ahsan Tarique