Help with function to reverse Stack

[BrettD565]

Hello! I am currently working on an assignment in which I am trying to create a function to reverse a stack if written in the format stack1.reverseStack(stack2), this line of code copies the elements of stack1 onto stack2 in reverse order.

The driver code was given to me by my professor and for some reason I think my method is correct but the driver will not print out the new stack.
Thanks for helping!

Stack240.h

  //Header file: Stack240.h


#ifndef H_Stack240
#define H_Stack240

#include <iostream>
#include <cassert>

#include "AbstractStack240.h"

using namespace std;

template <class Type>
class Stack240: public AbstractStack240<Type>
{
public:
    const Stack240<Type>& operator=(const Stack240<Type>&);
      //Overload the assignment operator.

    void initializeStack();
      //Function to initialize the stack to an empty state.
      //Postcondition: stackTop = 0

    bool isEmptyStack() const;
      //Function to determine whether the stack is empty.
      //Postcondition: Returns true if the stack is empty,
      //               otherwise returns false.

    bool isFullStack() const;
      //Function to determine whether the stack is full.
      //Postcondition: Returns true if the stack is full,
      //               otherwise returns false.

    void push(const Type& newItem);
      //Function to add newItem to the stack.
      //Precondition: The stack exists and is not full.
      //Postcondition: The stack is changed and newItem
      //               is added to the top of the stack.

    Type top() const;
      //Function to return the top element of the stack.
      //Precondition: The stack exists and is not empty.
      //Postcondition: If the stack is empty, the program
      //               terminates; otherwise, the top element
      //               of the stack is returned.

    void pop();
      //Function to remove the top element of the stack.
      //Precondition: The stack exists and is not empty.
      //Postcondition: The stack is changed and the top
      //               element is removed from the stack.

    void reverseStack(Stack240<Type>& stack1);
      //Function to reverse the order of the stack.
      //Precondition: The stack exists and is not empty.
      //Postcondition: The stack is changed so that the
      //oldest element of the stack is now on top, and
      //the newest element of the stack is on the bottom.

    Stack240(int stackSize = 100);
      //constructor
      //Create an array of the size stackSize to hold
      //the stack elements. The default stack size is 100.
      //Postcondition: The variable s240Array contains the base
      //               address of the array, stackTop = 0, and
      //               maxStackSize = stackSize.

    Stack240(const Stack240<Type>& otherStack);
      //copy constructor

    ~Stack240();
      //destructor
      //Remove all the elements from the stack.
      //Postcondition: The array (s240Array) holding the stack
      //               elements is deleted.

//ToDo: declare the member function reverseStack() here
// according to the assignment requirements:


private:
    int maxStackSize; //variable to store the maximum stack size
    int stackTop;     //variable to point to the top of the stack
    Type *s240Array;       //pointer to the array that holds the
                      //stack elements

    void copyStack(const Stack240<Type>& otherStack);
      //Function to make a copy of otherStack.
      //Postcondition: A copy of otherStack is created and
      //               assigned to this stack.
};

template <class Type>
void Stack240<Type>::initializeStack()
{
    stackTop = 0;
}//end initializeStack

template <class Type>
bool Stack240<Type>::isEmptyStack() const
{
    return(stackTop == 0);
}//end isEmptyStack

template <class Type>
bool Stack240<Type>::isFullStack() const
{
    return(stackTop == maxStackSize);
} //end isFullStack

template <class Type>
void Stack240<Type>::push(const Type& newItem)
{
    if (!isFullStack())
    {
        s240Array[stackTop] = newItem;   //add newItem to the
                                    //top of the stack
        stackTop++; //increment stackTop
    }
    else
        cerr << "Cannot add to a full stack." << endl;
}//end push

template <class Type>
Type Stack240<Type>::top() const
{
    assert(stackTop != 0);          //if stack is empty,
                                    //terminate the program
    return s240Array[stackTop - 1];      //return the element of the
                                    //stack indicated by
                                    //stackTop - 1
}//end top

template <class Type>
void Stack240<Type>::pop()
{
    if (!isEmptyStack())
        stackTop--;                 //decrement stackTop
    else
        cerr << "Cannot remove from an empty stack." << endl;
}//end pop

template <class Type>
Stack240<Type>::Stack240(int stackSize)
{
    if (stackSize <= 0)
    {
        cerr << "Size of the array to hold the stack must "
             << "be positive." << endl;
        cerr << "Creating an array of size 100." << endl;

        maxStackSize = 100;
    }
    else
        maxStackSize = stackSize;   //set the stack size to
                                    //the value specified by
                                    //the parameter stackSize

    stackTop = 0;                   //set stackTop to 0
    s240Array = new Type[maxStackSize];  //create the array to
                                    //hold the stack elements
}//end constructor

template <class Type>
Stack240<Type>::~Stack240() //destructor
{
    delete [] s240Array; //deallocate the memory occupied
                    //by the array
}//end destructor

template <class Type>
void Stack240<Type>::copyStack(const Stack240<Type>& otherStack)
{
    delete [] s240Array;
    maxStackSize = otherStack.maxStackSize;
    stackTop = otherStack.stackTop;

    s240Array = new Type[maxStackSize];

        //copy otherStack into this stack
    for (int j = 0; j < stackTop; j++)
        s240Array[j] = otherStack.s240Array[j];
} //end copyStack

template <class Type>
Stack240<Type>::Stack240(const Stack240<Type>& otherStack)
{
    s240Array = nullptr;

    copyStack(otherStack);
}//end copy constructor

template <class Type>
const Stack240<Type>& Stack240<Type>::operator=
   					(const Stack240<Type>& otherStack)
{
    if (this != &otherStack) //avoid self-copy
        copyStack(otherStack);

    return *this;
} //end operator=

//ToDo
template<class Type>
void Stack240<Type>::reverseStack(Stack240<Type> &stack2)
{
   int stackit;  // suggested for traversing the stack
   Stack240<Type> stack1;
   stack2.initializeStack();

// If this stack's actual size exceeds the
// other stack's capacity, then there isn't enough
// room for the operation.  Fill in the if-condition and
// if-body below to send an informative message to cerr
// (or cout) if this happens.  There's no need to exit
// explicitly, as the program will be finished anyway.
// You are not required to use exceptions in this
// exercise.  Then you can put the main logic of your
// reverse-copy in the else-body.
   if (stack1.stackTop > stack2.maxStackSize)
   {
	   cerr << "Cannot reverse a stack that has a bigger range than the resulting stack's max size." << endl;
   }
   else
   {
	   while (!stack1.isEmptyStack())
	      {
	         stackit = stack1.top();
	         stack2.push(stackit);
	         stack1.pop();
	      }
   }
}

#endif 

driverStack240.cpp

#include <iostream>
#include "Stack240.h"

using namespace std;

int main()
{
	Stack240<int> stack1(50);
	Stack240<int> stack2(50);

	stack1.initializeStack();
	stack1.push(23);
	stack1.push(45);
	stack1.push(58);
	stack1.push(3);
	stack1.push(29);
	stack1.push(82);

	stack1.reverseStack(stack2);

	cout << "stack1: ";

	while (!stack1.isEmptyStack())
	{
		cout << stack1.top() << " ";
		stack1.pop();
	}

	cout << endl;

	cout << "stack2: ";

	while (!stack2.isEmptyStack())
	{
		cout << stack2.top() << " ";
		stack2.pop();
	}

	cout << endl;
	return 0;
}

[BrettD565]

AbstractStack240.h

//Header file: AbstractStack240.h
// wrb 2018
// Students do not change this file
#ifndef H_AbstractStack240
#define H_AbstractStack240

template <class Type>
class AbstractStack240
{
public:
    virtual void initializeStack() = 0;
	// Initializes to an empty state.
	//Postcondition: Stack is empty

    virtual bool isEmptyStack() const = 0;
      //Returns whether the stack is empty.

    virtual bool isFullStack() const = 0;
      //Returns whether the stack is full.

    virtual void push(const Type& newItem) = 0;
      //Adds newItem to the stack.
      //Precondition: The stack exists and is not full.
      //Postcondition: newItem is added to the top of
      // the stack.

    virtual Type top() const = 0;
      //Returns the top element of the stack.
      //Postcondition: If the stack is empty the program
      //terminates; otherwise, returns the top element
      // of the stack.

    virtual void pop() = 0;
      //Removes the top element of the stack.
      //Precondition: The stack exists and is not empty.
      //Postcondition: The top element is removed.
};

#endif 

[lastchance]

On line 209:
Stack240<Type> stack1( *this );
Otherwise, stack1 has nothing in it.

However, it would be far simpler just to copy the array elements (in reverse) using a simple for loop.

[BrettD565]

@lastchance Thank you! So obvious when someone else points it out!