为什么我会收到"invalid conversion from 'Queue*/Stack*' to 'int'"错误消息？

Question

为什么我会收到这些错误？

从"队列*"到"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;
}

队列.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];
}
}
};

主.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：错误：从"队列*"到"int"的转换无效 [-允许] 队列 q = 新队列((; ^~~~~~~~~~~ 20：12：错误：请求从"堆栈*"转换为非标量类型"堆栈" 堆栈 s = 新堆栈((; ^~~~~~~~~~~

Answer 1

错误将来自main.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++(