Блог

Поэтому я пытаюсь понять, как создать класс стека с реализацией массива, используя значения типа double.

Вот полный файл заголовка…

 #ifndef STACK_H
#define STACK_H

class Stack
{
private:
    double *stackArray;             //Pointer to the Stack array.
    int stackSize;                  //The size of stack.
    int top;                        //The first "plate" on top of the stack.
    
    void copy(const Stack amp;copy);  //Copy Constructor 
    void destroy();                 //The fxn the destructor calls.

public:
    Stack(int);                    //Constructor
    
    /*
    Stack(const Stackamp;);            //Copy Constructor 
    */
    ~Stack();                          //Destructor 
    
    
    //STACK OPERATIONS:
    void push(double);              //Adds a node on top of the stack. 
    
    void pop(double amp;);                     //Removes node on top of stack. 
    
    bool isEmpty() const;           //Returns true if stack is empty, false otherwise.
    
    bool isFull() const;            //Returns true if stack is full, false otherwise.
    
    double peek();                  //Gets the top item of the stack without removing the item. 
    
    int getSize();                  //Makes the array larger if the capacity of the array is being reached. 
};
#endif
 

И вот полный файл реализации…

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

Stack::Stack(int size)                    //The Constructor 
{
    stackArray = new Stack[size];       //Dynamically allocate memory for an array of a stack variable.
    stackSize = size;
    top = -1;                           //Set the top of the stack to -1. So its empty.
}


Stack::~Stack()                         //The destructor 
{
    destroy();                          //Calls the destroy function to delete the array.
}



  void Stack::push(double value)          //Adds a new 'plate' on the stack 
{
    if (isFull())
    {
        cout << "The stack is full.n";         //Prints out a message saying the stack is already full 
    }
    else                                        //Otherwise...
    {
        top  ;                                  //Increment top....
        stackArray[top] = value;                //...So we can make 'value' the new top in the array.
    }
}

void Stack::pop(double amp;value)                 //Removes a 'plate' from the stack 
{
    if (isEmpty())
    {
        cout << "The stack is empty.n";
    }
    else                                        //Otherwise...
    {
        value = stackArray[top];                //Make 'value' the current top.
        top--;                                  //Removes the current value of top from the stack. 
    }
}


bool Stack::isEmpty() const
{
    bool status;                        //Tells the current status of the stack
    
    if (top == -1)                           //If theres nothing in the stack...
    {
        status = true;                 //...status returns true. 
    }
    else                              //Otherwise...
    {
        status = false;              //...The stack MUST have something already in it.
    }
    
    return status;                  
}


bool Stack::isFull() const
{
    bool status;                    
    
    if (top == stackSize - 1)               //Checks if the top of the stack is equal to the max stack size entered.
        status = true;                      //Returns true if stack is full.
    else
        status = false;                     //Or false if not.
    
    return status;          
}


void Stack::destroy()
{
    delete [] stackArray;           //Delete the Stack Array.
}


double Stack::peek()            //Gets the top item of the stack without removing item 
{
    return stackArray[top];
}


int Stack::getSize()                                        //Determines the size of the stack
{
    int numItems = 0;                                       //Variable to store number of items in stack.
    
    for (int index = 0; index < stackSize; index  )         //Goes through all the items in the stack....
    {
        numItems  ;                                         //...and counts them.
    }
    
    return numItems;
}

/****
void copy(const Stack amp;copy)        //Deletes memory associated with stack
{
    
}
***/
 

Водитель выглядит так….

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

int main()
{
    int stackSize;
    
    Stack stack1(10);
    
    cout << "Lets get the stack size!n";
    cout << stack1.getSize();

    return 0;
}
 

Моя проблема в том, что, когда я пытаюсь запустить это, это выдает мне следующую ошибку:

     Stack.cpp: In constructor ‘Stack::Stack(int)’:
Stack.cpp:13:32: error: no matching function for call to ‘Stack::Stack()’
     stackArray = new Stack[size];       //Dynamically allocate memory for an array of a stack variable.
                                ^
In file included from Stack.cpp:6:0:
Stack.h:20:9: note: candidate: Stack::Stack(int)
         Stack(int);                    //Constructor
         ^~~~~
Stack.h:20:9: note:   candidate expects 1 argument, 0 provided
Stack.h:9:7: note: candidate: constexpr Stack::Stack(const Stackamp;)
 class Stack
       ^~~~~
Stack.h:9:7: note:   candidate expects 1 argument, 0 provided
Stack.cpp:13:32: error: cannot convert ‘Stack*’ to ‘double*’ in assignment
     stackArray = new Stack[size];       //Dynamically allocate memory for an array of a stack variable.
 

Я не совсем уверен, что здесь происходит, если кто-нибудь может мне помочь, это было бы действительно здорово.

Также может ли кто-нибудь дать мне несколько советов о том, как мне следует обращаться к конструктору копирования и перегруженному оператору присваивания для этого класса? Я не очень хорошо разбираюсь в них и не уверен, как они впишутся в этот класс.

Это конструктор, который вы пытаетесь вызвать

 Stack::Stack(int size)                    //The Constructor 
{
    stackArray = new Stack[size];       //Dynamically allocate memory for an array of a stack variable.
    stackSize = size;
    top = -1;                           //Set the top of the stack to -1. So its empty.
}
 

Теперь обратите внимание, что в конструкторе вы выделяете динамический массив Stack s и размера size .

Здесь stackArray = new Stack[size]

У вас две проблемы

1. Распределение использует конструктор по умолчанию для стека, а у вас его нет, потому что вы объявили пользовательский.
2. Если вы используете пользовательский конструктор, у вас будет бесконечная рекурсия.

Вы должны указать правильный тип элементов массива, которые будут выделены (что, судя по остальному коду, похоже double ), а Stack не тип, который будет

stackArray = new double[size] .