c++ Stack Array implementation and display error

Question

So in my assignment we're supposed to be creating a Stack class that creates a stack using array implementation for values of type double.

Here's the header file:

#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/Holds the index of the first element in the stack
        
        void copy(const Stack &copy);  //The fxn the copy constructor calls. 
        void destroy();                 //The fxn the destructor calls.
        void resize();                  //Makes the array larger if capacity has been reached.
        
    public:
        Stack();                    //Default Constructor
        /***
        Stack(const Stack&);            //Copy Constructor 
        ***/
        
        ~Stack();                          //Destructor 
        
        
        //STACK OPERATIONS:
        void push(double);              //Adds a 'plate' on top of the stack. 
        
        void pop();             //Removes 'plate' on top of stack. 
        
        bool isEmpty();           //Returns true if stack is empty, false otherwise.
        
        bool isFull();            //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. 
        
        void display() const;  //Displays the values in the stack.
};
#endif 

Heres the implementation file:

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


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

/***
Stack::Stack(const Stack &obj)                     //The Copy constructor 
{
    copy(const Stack &copy);
}
***/


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())
    {
        resize();                       //Makes a new stack that is double the size of the current one 
                                       //While copying all values of the previous stack.
        push(value);
    }
    
    top++;                                  //Increment top....
    stackArray[top] = value;                //...So we can make 'value' the new top in the array.
}


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


bool Stack::isEmpty() 
{
    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() 
{
    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
{
    return top + 1;
}


void Stack::resize()
{
    
    stackSize *= 2;                                         //Make the stackSize of the new array 
                                                            //AT LEAST TWICE as big as the previous one. 

   double *stackArray2nd = new double[stackSize];                     //Make new array
    
    for (int index = 0; index <= top; index++)
    {
        stackArray2nd[index] = stackArray[index];          //Make the new stack array equal to the old stack array.
    }
    
    destroy();
    stackArray = stackArray2nd;                         //Stack array no longer has a size associated with it 
}




void Stack::copy(const Stack &copy)    
{
    stackSize = copy.stackSize;                         //Copy the stackSize attribute.
    
    for (int index = 0; index < stackSize; index++)    //Copy the Stack's contents 
        stackArray[index] = copy.stackArray[index];    
        
    top = copy.top;                                   //Set the top of the stack.
}


void Stack::display() const                       //Prints out the stack 
{
    for (int index = 0; index <= top; index++)
    {
        cout << stackArray[index] << " ";
    }
    cout << endl;
}

And here's the driver program:

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

int main()
{
    
    Stack stack1;
    
    cout << "Lets get the stack size!\n";           //Check to see if the getSize function works 
    cout << stack1.getSize();
    
    cout << "\nLets see if we can add a value on to the stack!\n";
    stack1.push(33.2);
    stack1.display();
    
    cout << "\nLets add another.\n";
    stack1.push(27.4);
    stack1.display();

    return 0;
}

My issue is that when I try to run it, it compiles, but for some reason I get this:

Lets get the stack size!
0
Lets see if we can add a value to the stack!
33.2

Lets add another.
33.2 27.4 27.4

Why does it add another 27.4? Also theres the issue where I cant seem to get the value being pushed into the array get printed out as the first value on the far left side.

Please help! I'm not exactly sure why this is happening.