Почему я получаю сообщение об ошибке «Недопустимое преобразование из очереди / стека * в int»?

Question

Почему я получаю эти ошибки?

недопустимое преобразование из 'Queue *' в 'int'

преобразование из'Stack *' для нескалярного типа 'Stack запрашивается

Я пытался изменить Queue & Stack, но безрезультатно. Я выполняю задание, которое реализует Stack с использованием Queue s & Implements Queue с использованием Stack s.

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

Когда вы создаете экземпляр с ключевым словом new, вы создаете указатель на объект. Таким образом, правильное создание будет следующим:

Queue * q = new Queue();

Stack * s = new Stack();

Когда x является указателем, тогда значение x является адресом объекта, а *x является фактическим объектом.

Answer 2

Ошибка будет исходить из строки в 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 3

Я не согласен с ответами, рекомендующими заставить его работать с new. Это не нужно.

Вместо использования new просто оставьте их как обычные переменные стека. Тогда вы не обременены необходимостью позже delete и вам не нужно заменять все экземпляры от . до ->.

Просто

Queue q;
Stack s;

И ваша программа остаётся без изменений.

(Возможно, вы пришли из c # фона? new необходим там, но чаще всего не нужен с C ++)