copy an instance of a Stack class?

[drunkenmonk]

Hello, I am trying to write a program that manipulates a stack containing integers. I have written al the usual: Push, Pop, Print, etc.. My last operator is called Copy. When called (stackA.Copy( stackB ) whatever was in stackA is deep copied into stackB. here is my code:


Stack.h:

//=======
//Stack.h
//=======
//    |
//  \ |	/
//   \|/
//	  V
//  ===========
   #pragma once
//  ===========

//  ===========
    class Stack
    {
//      =========
//      Constants
//		======================================
        const static int MAX_STACK_SIZE = 200;
		//      ======================================

//		=======
        public:
//		=======

//			============
//			Constructors
//			=============
	        Stack(void);
//			============

//			==========
//			Destructor
//			============
	       ~Stack(void);
//          ============

//          ================
//			Member Functions
//          ==========================
            void Stack::PurgeStack( );
            void Stack::InitializeStack( );
            void Stack::Pop( int& );
	        void Stack::PrintStack( );
            void Stack::Push( int );
            bool Stack::StackEmpty( );
            bool Stack::StackFull( );
			int Stack::SumOfElements(int& );
			void Stack::Average( );
			void Stack::Roll( );
			void Stack::Copy( Stack& );
//          =========================

//		========
	    private:
//		========

//          ================
//          Member variables
//          ========
	        int top;
	        int elements[MAX_STACK_SIZE];
//          =============================

    }; // Class Stack
//  =================

//===========
//End Stack.h
//=========== 

Stack.cpp:

//=========
//Stack.cpp
//=========
//    |
//  \ |	/
//   \|/
//	  V
//=================
#include "StdAfx.h"
#include <iostream>
#include <iomanip>
//=================

#include "Stack.h"
//================

//==================
using namespace std;
//==================

//  ============
//  Constructors
//  ============
        
//      ===================
//      Default Constructor
//		==================== 
        Stack::Stack( void )
        {
			PurgeStack();
        } //End Constructor
//		===================

//  ==========
//  Destructor
//	=====================
    Stack::~Stack( void )
    {

    } //End Destructor
//	==================

//  ================
//  Member-Functions
//  ================
        
//      ===================
//		Function PurgeStack
//      =========================
        void Stack::PurgeStack( )
        {
            for (int ii = 0; ii < MAX_STACK_SIZE; ii++)
			{
                elements[ii] = 0;
	        } 
	        top = 0;
        }//End Function PurgeStack
//      ==========================

//      ========================
//		Function InitializeStack
//		==============================
        void Stack::InitializeStack( )
        {
            top = 0;
        }//End Function InitializeStack
//      ===============================

//      ============
//		Function Pop
//      ===================================
        void Stack::Pop( int& poppedValue )
        {
			if (!StackEmpty()){
	        top--;
            poppedValue = elements[top];
			PrintStack();
		}
			else
			PrintStack();
        } // Member-Function Pop
//      ========================

//      ===================
//      Function PrintStack
//      =========================      
	    void Stack::PrintStack( )
        {
			cout << endl << endl;
            cout << "+ Top of Stack  +" << endl;
			cout << "=+=+=+=+=+=+=+=+=" << endl;
			cout << endl;
            if ( StackEmpty() )
                cout << "The stack is empty." << endl;
            else{
                for ( int ii = top - 1; ii >= 0; ii-- ){
                    cout << "At index[" << ii << "] = "
                         << elements[ii] << endl;
                } // for
            } // else
			cout << endl;
			cout << "=+=+=+=+=+=+=+=+=" << endl;
            cout << "+Bottom of Stack+" << endl << endl;
        }//End Function PrintStack
//      ==========================

//      =============
//		Function Push
//		===================================
        void Stack::Push( int pushedValue ) 
        {
            elements[top] = pushedValue;
            top++;
			PrintStack();
        }//End Function Push
//      =========================

//      ===================
//		Function StackEmpty
//      =========================
        bool Stack::StackEmpty( )
        {
            return (top == 0);
        }//End Function StackEmpty
//      ==========================

//      ==================
//		Function StackFull
//      ========================
        bool Stack::StackFull( )
        {
            return (top == MAX_STACK_SIZE);
        }//End Function StackFull
//      =========================

//      ======================
//		Function SumOfElements
//      ==================================
		int Stack::SumOfElements(int& sum)
		{
			sum = 0;
			for (int ii = 0; ii <= (top-1);ii++)
				sum = sum + elements[ii];
			cout << "Sum = " << sum << endl;
			return sum;
		}//End SumOfElements
//		====================

//      ================
//		Function Average
//      ======================
		void Stack::Average( )
		{
			cout << fixed << showpoint << setprecision(2);

			int sum;
			double result = 0;
			cout << endl;
			SumOfElements( sum );
			cout << endl;
			double total = sum;
			double divisor = top;

			if (sum == 0)
				cout << "Average = 0, the stack is empty" << endl << endl;
			else
			{
			result = total/ divisor;
			cout << "Average = " << result << endl << endl;
			}
		}

		void Stack::Roll( )
		{
			if (top == 0)
				cout << "Stack is empty, There are no elements to roll" << endl << endl;
			else if (top == 1)
				cout << "There is only one element in the stack, nothing to roll with" << endl << endl;
			else
			{
			int temp;
			temp = elements[top-1];
			elements[top-1] = elements[top-2];
			elements[top-2] = temp;
			PrintStack( );
			}
		}

		  void Stack::Copy( Stack& otherStack)
		{
			 top = otherStack.top;


			for ( int ii = top-1; ii >=0 ; ii--){

			elements[ii] = otherStack.elements[ii];
			}
	

		
		}





//  ====================
//  End Member-Functions
//  =====================

//=============
//End Stack.cpp
//============= 

Any help would be appreciated!!!

[kbw]

Your stack is a stack of ints held in a fixed array. You can do a bitwise copy.

void Stack::Copy(const Stack& otherStack)
{
    if (this != &otherStack)
        *this = otherStack;

    return *this;
}