C++动态扩容队列类实现咨询：初始容量X，满时扩容X

绝对应该把扩容逻辑封装在队列类的内部，这完全符合C++面向对象的封装原则，而且能让你的代码更健壮、更易维护。下面具体说原因和实现思路：

为什么要放在类内部？ #

• 封装性是核心：队列的容量、当前元素数量这些状态属于类的内部细节，外部代码（比如主函数）不需要关心这些。把扩容逻辑放在类里，外部只需要调用push()方法添加元素，不用管队列是不是满了、要不要扩容——这些都由类自己处理。
• 避免重复代码和人为错误：如果把扩容逻辑放在主函数里，你每次调用push()前都要手动检查队列是否已满，还要写扩容的代码。如果多个地方用到这个队列，你就得重复写这些逻辑，很容易出现判断错误、内存管理失误的问题。
• 代码复用性更强：以后在其他项目里复用这个队列类时，直接用就行，不用再重新写扩容相关的逻辑，降低了维护成本。

实现示例代码 #

这里给你一个简化版的实现，把初始容量和扩容步长都设为传入的X：

class Queue {
private:
    int* arr;
    int front;
    int rear;
    int currentSize;
    int capacity;
    int expandStep; // 每次扩容的大小，即你说的X

public:
    // 构造函数，初始化初始容量和扩容步长为X
    Queue(int X) : front(0), rear(-1), currentSize(0), capacity(X), expandStep(X) {
        arr = new int[capacity];
    }

    // 析构函数释放内存
    ~Queue() {
        delete[] arr;
    }

    // 入队方法，内部处理扩容逻辑
    void push(int val) {
        // 检查队列是否已满
        if (currentSize == capacity) {
            // 计算新容量：当前容量 + 扩容步长X
            int newCapacity = capacity + expandStep;
            int* newArr = new int[newCapacity];

            // 把原有元素复制到新数组（处理循环队列的情况）
            for (int i = 0; i < currentSize; ++i) {
                newArr[i] = arr[(front + i) % capacity];
            }

            // 释放旧数组内存，更新指针和容量
            delete[] arr;
            arr = newArr;
            front = 0;
            rear = currentSize - 1;
            capacity = newCapacity;
        }

        // 正常入队操作
        rear = (rear + 1) % capacity;
        arr[rear] = val;
        currentSize++;
    }

    // 其他必要方法示例：出队、获取队首、判断空
    void pop() {
        if (currentSize == 0) {
            // 可以抛出异常或做其他处理
            return;
        }
        front = (front + 1) % capacity;
        currentSize--;
    }

    int getFront() const {
        if (currentSize == 0) {
            // 处理空队列的情况
            return -1;
        }
        return arr[front];
    }

    bool isEmpty() const {
        return currentSize == 0;
    }
};

主函数的使用方式 #

主函数里只需要简单初始化队列，然后调用入队方法就行，完全不用管扩容：

int main() {
    // 初始化一个初始容量为3，每次扩容3的队列
    Queue q(3);

    q.push(1);
    q.push(2);
    q.push(3);
    // 此时队列已满，下一次push会自动扩容3个位置
    q.push(4);
    q.push(5);
    q.push(6);
    // 再次满了，继续扩容3个
    q.push(7);

    // 后续操作...
    return 0;
}

这种方式既简洁又安全，所有和队列内部状态相关的操作都由类自己处理，外部代码只需要关注业务逻辑即可。

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