简单的队列数据结构。内存位置？

Question

这个应该是栈操作吧？为了练习，这就是我想要的。但是，我根本无法在这段代码中使用指针，如果可能的话，我想在一些帮助下实现它。

我试过 ChatGpt，但它没有给我一个具体的答案。它总是尝试使用命令“new”将内存分配给堆。

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

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

Queue createQueue(){
    Queue queue;
    queue.front=-1;
    queue.back=-1;
    return queue;
}


bool isFull(Queue& queue){
    if (queue.back==max_size-1){
        cout<<"\nRed je pun.\n";
        return true;
    }
    return false;
};

void newElement(Queue& queue, int x){
    if (isFull(queue)){
        isFull(queue);
    }else if (!isFull(queue)){
        queue.back++;
        queue.arr[queue.back]=x;
    }
    
}

void takeElement(Queue& queue,int y){    // here i tried to take off one element from the Queue
    for (int i =0;i<=queue.back;i++){    // but then i understood that it isn't a Queue if you can do that
        if(queue.arr[i]==y){
            cout<<"Your number is: "<<queue.arr[i];
            for(int j=i;j<queue.back;j++){
                queue.arr[j]=queue.arr[j+1];
            }
            queue.back--;
        }
    }
}



void comeToElement(Queue& queue, int x){
    if (queue.back==-1 && queue.front==-1){
        cout<<"\nQueue is empty.\n";
    }else{
        queue.front=0;
        cout<<"\nDeleted part of the queue is: \n";
        for(int i=queue.front;i<=x;i++){
            cout<<queue.arr[i]<<" ";
            queue.front++;
        }
    }
}

void printQueue(Queue queue){
    if (queue.back==-1 and queue.front==-1){
        cout<<"\nRed je prazan.\n";
    }else{
        cout<<"\nYour elements of the queue are:\n";
        for (int i=queue.front;i<=queue.back;i++){
            cout<<queue.arr[i]<<" ";
        }
    }
    
}

void readMeni(){
    cout<<"\n\nPick a command: \n";
    cout<<"==============================\n";
    cout<<"1) Entry of a new element\n";
    cout<<"2) Taking an element from the Queue\n";
    cout<<"3) Print Queue \n";
    cout<<"4) Exit\n";
    cout<<"==============================\n\n\n";
}




int main(){
    int n;
    Queue queue = createQueue();
    while(!(n==4)){
        readMeni();
        cin>>n;
        if(n==1){
            cout<<"\n\nEnter te number which you want in the Queue:\n";
            int x;
            cin>>x;
            newElement(queue,x);
        }else if (n==2){
            cout<<"\n\nEnter the index of the number you want to delete:\n";
            int y;
            cin>>y;
            comeToElement(queue,y);
        }else if (n==3){
            printQueue(queue);
    }
    
}
cout<<"You have EXITED the programme.";
}

感谢您的宝贵时间！

此代码有效。但问题是指针的使用。

Answer 1

使用指针的一个主要优点是它减少了程序占用的堆栈空间总量。

以队列初始化行为例：

Queue queue = createQueue()

。信不信由你，这实际上创建了两个对象。第一个是在

createQueue

函数中通过语句

Queue queue;

创建的，这是因为当您以这种方式声明对象时，将调用默认的无参数构造函数。然后，

=

导致由

createQueue

创建的对象被 copied 到一个新变量。当然，

createQueue

的堆栈帧和在该函数中声明的任何变量在

createQueue

完成时被释放，因此在

Queue

行的末尾实际上只剩下一个

Queue queue = createQueue()

。

但是，如果您要重写您的

createQueue

函数以使其返回一个指针，然后在您的

main

中使

queue

成为一个指针，则只会创建一个

Queue

。例如：

Queue *createQueue() {
    Queue *queue = new Queue();
    queue->front = -1;
    queue->back = -1;
    return queue;
}
...
int main() {
   // ...
   Queue *queue = createQueue();
   // ...
}

现在，当您调用

createQueue

时，将再次使用默认的无参数构造函数创建一个新的

Queue

对象，但这次该对象进入堆。堆栈上的是一个指针，它保存着

Queue

对象的地址。回到

main

，该指针被分配给

queue

变量，您可以像在

queue

不是指针时一样轻松地访问它的成员。

为了获得更多技术性（也许您并不真正关心这一点，但我认为这很重要），假设一个

int

在您的系统上消耗四个字节的内存，那么一个

Queue

将占用408字节的内存。这意味着，在没有指针的情况下，堆栈中的 816 个字节用于

Queue

中的两个

Queue queue = createQueue()

。对于指针，假设指针需要八个字节的内存，堆上有 408 个字节，

Queue*

只会占用堆栈上的八个字节。

对象复制也会在您按值传递变量时发生，就像您在

printQueue

函数（即

printQueue(Queue queue)

）中所做的那样。因此，

queue

对象最终被复制，因此使用了额外的 408 字节堆栈空间，如果您使用指针，则不需要使用这些空间。