栈上实现队列结构：如何在现有代码中使用指针？

要在栈上用指针实现队列，核心是让指针指向栈上分配的队列实例，不需要用new在堆上分配内存。栈上的对象由编译器自动管理生命周期，指针仅作为操作栈上对象的入口。以下是基于现有代码修改后的实现：

关键改动说明 #

• 将原createQueue函数改为初始化函数，接收队列指针，避免返回栈上对象（更贴合指针操作的需求）
• 所有操作队列的函数参数从引用改为指针，通过->访问队列成员
• 主函数中直接在栈上创建队列实例，用指针传递给各个操作函数

修改后的完整代码 #

#include <iostream>
using namespace std;
#define max_size 100

struct Queue {
    int front;
    int back;
    int arr[max_size];
};

// 初始化栈上的队列，接收指针
void initQueue(Queue* queue) {
    queue->front = -1;
    queue->back = -1;
}

bool isFull(Queue* queue) {
    if (queue->back == max_size - 1) {
        cout << "\n队列已满。\n";
        return true;
    }
    return false;
}

void newElement(Queue* queue, int x) {
    if (isFull(queue)) {
        return; // 避免重复调用isFull输出提示
    }
    // 处理空队列的初始化
    if (queue->front == -1) {
        queue->front = 0;
    }
    queue->back++;
    queue->arr[queue->back] = x;
}

// 队列标准出队操作（FIFO，移除队首元素）
void dequeue(Queue* queue) {
    if (queue->front == -1 || queue->front > queue->back) {
        cout << "\n队列已空。\n";
        return;
    }
    cout << "\n出队元素：" << queue->arr[queue->front];
    queue->front++;
    // 队列空了则重置front和back
    if (queue->front > queue->back) {
        queue->front = queue->back = -1;
    }
}

// 移除从队首到指定索引的元素
void comeToElement(Queue* queue, int x) {
    if (queue->front == -1 || queue->front > queue->back) {
        cout << "\n队列已空。\n";
        return;
    }
    if (x < queue->front || x > queue->back) {
        cout << "\n索引无效。\n";
        return;
    }
    cout << "\n删除的队列部分：\n";
    for (int i = queue->front; i <= x; i++) {
        cout << queue->arr[i] << " ";
    }
    queue->front = x + 1;
    // 空队列重置
    if (queue->front > queue->back) {
        queue->front = queue->back = -1;
    }
}

void printQueue(Queue* queue) {
    if (queue->front == -1 || queue->front > queue->back) {
        cout << "\n队列已空。\n";
        return;
    }
    cout << "\n队列元素：\n";
    for (int i = queue->front; i <= queue->back; i++) {
        cout << queue->arr[i] << " ";
    }
}

void readMenu() {
    cout << "\n\n选择操作：\n";
    cout << "==============================\n";
    cout << "1) 入队新元素\n";
    cout << "2) 移除指定索引前的元素\n";
    cout << "3) 标准出队（移除队首）\n";
    cout << "4) 打印队列\n";
    cout << "5) 退出\n";
    cout << "==============================\n\n";
}

int main() {
    int n;
    // 在栈上创建队列实例
    Queue queue;
    // 用指针指向栈上的队列
    Queue* queuePtr = &queue;
    initQueue(queuePtr);

    while (n != 5) {
        readMenu();
        cin >> n;
        if (n == 1) {
            cout << "\n输入要入队的数字：\n";
            int x;
            cin >> x;
            newElement(queuePtr, x);
        } else if (n == 2) {
            cout << "\n输入要删除到的索引：\n";
            int y;
            cin >> y;
            comeToElement(queuePtr, y);
        } else if (n == 3) {
            dequeue(queuePtr);
        } else if (n == 4) {
            printQueue(queuePtr);
        } else if (n == 5) {
            cout << "已退出程序。";
        } else {
            cout << "\n无效操作，请重新选择。\n";
        }
    }
    return 0;
}

额外说明 #

1. 原代码中的takeElement不符合队列FIFO的特性，队列只能从队首出队，因此新增了标准的dequeue函数
2. 所有操作都通过指针queuePtr访问栈上的queue实例，全程未使用堆内存（无new/delete）
3. 修正了空队列的判断逻辑，避免索引越界问题

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