为什么我会收到“从 'Queue*/Stack*' 到 'int' 的无效转换”错误消息？

Question

为什么会出现这些错误？

从 'Queue*' 到 'int' 的无效转换

请求从“堆栈*”转换为非标量类型“堆栈”

我尝试修改Queue & Stack，但无济于事。我正在做一个使用Queues 实现Stack 并使用Stacks 实现Queue 的作业。

Stack.h

#ifndef STACK_H_
#define STACK_H_
#include <iostream>
using namespace std;

class Stack {
    int size;
    int capacity; // for dynamic allocated array
    int stackTop;
    int *arr;

public:
    Stack();
    void push(int val);
    int pop();
    bool isFull();
    bool empty();
    int top();
    int peek(int pos);
    int resize();
};

bool Stack::empty(){
    return size == 0;
}

bool Stack::isFull(){
    return size == capacity;
}

void Stack::push(int val){

    if(isFull())
        resize();

    arr[++stackTop] = val;
    size++;
}

int Stack::pop(){

    if(empty())
        return true;

    return arr[stackTop--];

}

int Stack::peek(int pos){

    if(pos > stackTop || pos < 0){
        cout << "Empty Stack";
        return 0;
    }
    else{
        return arr[size - pos - 1];
    }
}

int Stack::top(){

    if(empty()){
        return true;
    }

    return *arr;

}

int Stack::resize(){

    return size;
}

Queue.h

#ifndef QUEUE_H_
#define QUEUE_H_
#include <iostream>
using namespace std;

class Queue{

    int f, r, *arr, size, capacity;

public:

    Queue(): f(-1), r(-1), arr(nullptr), size(0), capacity(0){}
    Queue(int cap): f(-1), r(-1), arr(new int[cap]), size(0), capacity(cap){}
    ~Queue(){delete []arr;}

    Queue(const Queue &copy){

        f = copy.f;
        r = copy.r;
        arr = copy.arr;
        size = copy.size;
        capacity = copy.capacity;
    }

    Queue(Queue&& move){

        f = move.f;
        r = move.r;
        arr = move.arr;
        size = move.size;
        capacity = move.capacity;

        move.f = -1;
        move.r = -1;
        move.arr = nullptr;
        move.size = 0;
        move.capacity = 0;
    }

    Queue& operator=(const Queue& copyA){

        if(this == &copyA){

            return *this;
        }

        f = copyA.f;
        r = copyA.r;
        arr = copyA.arr;
        size = copyA.size;
        capacity = copyA.capacity;
    }

    Queue& operator=(const Queue&& moveA){

        if(this == &moveA){

            return *this;
        }

        f = moveA.f;
        r = moveA.r;
        arr = moveA.arr;
        size = moveA.size;
        capacity = moveA.capacity;

//      moveA.f = -1;
//      moveA.r = -1;
//      moveA.arr = nullptr;
//      moveA.size = 0;
//      moveA.capacity = 0;

        return *this;
    }

    void enqueue(int x){
        if(!full())
            resize();
        arr[f + r] = x;
        size++;
    }


    int dequeue(){
        if(!empty()){
            return arr[++f];
        } return -99999;
    }

    bool empty(){
        return size == 0;
    }

    bool full(){
        return size == capacity;
    }

    int peek(int pos){

        if(pos > capacity || pos < 0){
            cout << "Empty Queue";
            return 0;
        }else{
            return arr[size - pos - 1];
        }
    }

    void resize(){
        int newSize = this->size * 2;
        Queue *temp = new Queue[newSize];
        int count = 0;

        for(int i = 0; i < count; ++i){
            int index = (f + 1) % size;
            temp[i] = arr[index];
        }
    }
};

ma​​in.cpp

#include <iostream>
#include "Queue.h"
#include "Stack.h"
using namespace std;

int main(){

    Queue q = new Queue(); //invalid conversion from 'Queue*' to 'int' [-fpermissive]

    q.enqueue(1);
    q.enqueue(2);
    q.enqueue(3);

    cout << q.dequeue() << '\n';
    cout << q.dequeue() << '\n';
    cout << q.dequeue() << '\n';

    cout << endl;

    Stack s = new Stack(); //conversion from 'Stack*' to non-scalar type 'Stack' requested
    s.push(1);
    s.push(2);
    s.push(3);

    cout << "current size: " << s.resize() << endl;
    cout << s.top() << endl;

    s.pop();

    cout << s.top() << endl;

    s.pop();

    cout << s.top() << endl;

    cout << "current size: " << s.resize() << endl;


    return 0;
}

main.cpp:8:12：错误：从 'Queue*' 到 'int' 的无效转换 [-fpermissive] 队列 q = new Queue(); ^~~~~~~~~~~ 20:12：错误：请求从“堆栈*”转换为非标量类型“堆栈” 堆栈 s = 新堆栈（）； ^~~~~~~~~~~

Answer 1

错误来自 ma​​in.cpp 中的行：

Queue q = new Queue();

new 关键字创建一个指向类对象的指针，因此正确的语法是：

Queue *q = new Queue();

这也显示在此处的 C++ 教程文档中：http://www.cplusplus.com/doc/tutorial/classes/#pointers_to_classes

Stack 指针变量也是如此。

请注意，这也意味着使用对象的语法也必须改变。

代替：

s.pop();

您需要将其修改为：

(*s).pop();

或

s->pop();

希望这会有所帮助！

Answer 2

当您使用new 关键字进行实例化时，您会创建一个指向该对象的指针。因此，正确的实例化如下：

Queue * q = new Queue();

Stack * s = new Stack();

当x是指针时，x的值是对象的地址，*x是实际的对象。

Answer 3

我不同意建议让它与new 一起工作的答案。这是不必要的。

不要使用new，只需将它们保留为普通堆栈变量即可。这样您就不必为以后的delete 感到负担，也不必将. 的所有实例替换为->。

简单

Queue q;
Stack s;

您的程序在其他方面保持不变。

（您可能来自c# 背景吗？new 在那里是必需的，但在 C++ 中通常不需要）