Question

为什么会出现这些错误？

从“队列*”到“ int”的无效转换

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

我尝试修改Queue和Stack，但无济于事。我正在执行一项任务，该任务使用Stack s实现Queue和使用Queue s实现Stack。

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];
        }
    }
};

main.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: error: invalid conversion from 'Queue*' to 'int' [-fpermissive]
  Queue q = new Queue();
            ^~~~~~~~~~~

20:12: error: conversion from 'Stack*' to non-scalar type 'Stack' requested
  Stack s = new Stack();
            ^~~~~~~~~~~

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 ++来说通常不是必需的）

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

3 个答案: