C++ template class reference pass by-reference

Question

i was studying template classes andi have seen a tutorial code in a book. There is a class named Stack as the following:

// Stack class template.
#ifndef STACK_H
#define STACK_H

template< typename T >
class Stack 
{
public:
   Stack( int = 10 ); // default constructor (stack size 10)

   // destructor
   ~Stack() 
   { 
      delete [] stackPtr; // deallocate internal space for stack
   } // end ~Stack destructor

   bool push( const T& ); // push an element onto the stack
   bool pop( T& ); // pop an element off the stack

   // determine whether Stack is empty
   bool isEmpty() const 
   { 
      return top == -1; 
   } // end function isEmpty

   // determine whether Stack is full
   bool isFull() const 
   { 
      return top == size - 1; 
   } // end function isFull

private:
   int size; // # of elements in the stack
   int top; // location of the top element (-1 means empty)
   T *stackPtr; // pointer to internal representation of the stack
}; // end class template Stack

// constructor template
template< class T >
Stack< T >::Stack( int s )
   : size( s > 0 ? s : 10 ), // validate size
     top( -1 ), // Stack initially empty
     stackPtr( new T[ size ] ) // allocate memory for elements
{
   // empty body
} // end Stack constructor template

// push element onto stack;
// if successful, return true; otherwise, return false
template< class T >
bool Stack< T >::push( const T &pushValue )
{
   if ( !isFull() ) 
   {
      stackPtr[ ++top ] = pushValue; // place item on Stack
      return true; // push successful
   } // end if

   return false; // push unsuccessful
} // end function template push

// pop element off stack;
// if successful, return true; otherwise, return false
template< class T > 
bool Stack< T >::pop( T &popValue )
{
   if ( !isEmpty() ) 
   {
      popValue = stackPtr[ top-- ]; // remove item from Stack
      return true; // pop successful
   } // end if

   return false; // pop unsuccessful
} // end function template pop

#endif

Also there is a main tester function that uses a function template as following.

// Fig. 14.4: fig14_04.cpp
// Stack class template test program. Function main uses a 
// function template to manipulate objects of type Stack< T >.
#include <iostream>
#include <string>
#include "Stack.h" // Stack class template definition
using namespace std;

// function template to manipulate Stack< T >               
template< typename T >                                         
void testStack(                                             
   Stack< T > &theStack, // reference to Stack< T >         
   T value, // initial value to push                        
   T increment, // increment for subsequent values          
   const string stackName ) // name of the Stack< T > object
{                                                           
   cout << "\nPushing elements onto " << stackName << '\n'; 

   // push element onto Stack                               
   while ( theStack.push( value ) )                         
   {                                                        
      cout << value << ' ';                                 
      value += increment;                                   
   } // end while                                           

   cout << "\nStack is full. Cannot push " << value         
      << "\n\nPopping elements from " << stackName << '\n'; 

   // pop elements from Stack                               
   while ( theStack.pop( value ) )                          
      cout << value << ' ';                                 

   cout << "\nStack is empty. Cannot pop" << endl;                
} // end function template testStack                                 

int main()
{
   Stack< double > doubleStack( 5 ); // size 5  
   Stack< int > intStack; // default size 10

   testStack( doubleStack, 1.1, 1.1, "doubleStack" );
   testStack( intStack, 1, 1, "intStack" );
   system("pause");
} // end main

What could be reason usage of reference in testStack function? When i make change denition as

Stack< T > theStack,

i get an error message that says "debug assertion failed" after program ends.

Answer 1

There is no copy constructor in Stack, so when you replace

Stack<T>& 

to

Stack<T> 

the default ctor is used.

The second copy is destroying already cleaned pointer.

delete[] stackPtr; 

Answer 2

i think the best think is using reference when using a class's instance as a function parameter. But i just wanted to try copy constructor and added following code into Stack class and nothing changed. Error message appeared again with program end. What could be the correct copy constructor function?

// copy constructor template
template< typename T >
Stack< T >::Stack(const Stack &something)
{
    top = something.top;
    size = something.size;
    stackPtr = something.stackPtr;
}