Question

My Output

s1 (size 0):
s1 is empty

Testing push()

s1 (size 1): 17
s1 is not empty

s1 (size 4): 4 6 2 17
s1 is not empty

Testing copy constructor

s1 (size 4): 4 6 2 17
s2 (size 4): 4 6 2 17

Testing clear()

s1 (size 0):
s2 (size 4): 0 1477251200 1477251168 1477251136

s3 (size 4): 28 75 41 36

Testing assignment operator

s3 (size 4): 28 75 41 36
s4 (size 4): 28 75 41 36

s3 (size 0):
s4 (size 4): 0 1477251200 1477251168 1477251136

Testing assignment to self

s3 (size 4): 1477251104 1477251200 1477251168 1477251136
s4 (size 0):

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Output I need

Testing default constructor

s1 (size 0): 
s1 is empty

Testing push()

s1 (size 1): 17 
s1 is not empty

s1 (size 4): 4 6 2 17 
s1 is not empty

Testing copy constructor

s1 (size 4): 4 6 2 17 
s2 (size 4): 4 6 2 17 

Testing clear()

s1 (size 0): 
s2 (size 4): 4 6 2 17 

s3 (size 4): 28 75 41 36 

Testing assignment operator

s3 (size 4): 28 75 41 36 
s4 (size 4): 28 75 41 36 

s3 (size 0): 
s4 (size 4): 28 75 41 36 

Testing assignment to self

s3 (size 4): 28 75 41 36 
s4 (size 0): 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

My Code

#ifndef STACK_H
#define STACK_H

#include <iostream>

template <class T>
struct Node
{
T data;
Node<T>* next;

Node(const T& = T(), Node<T>* next = NULL);
};

template <class T>
Node<T>::Node(const T& data, Node<T>* next)
{
this->next = next;
this->data = data;
}

template <class T>
class Stack;

template <class T>
std::ostream& operator<<(std::ostream&, const Stack<T>&);

template <class T>
class Stack
{
friend std::ostream& operator<< <>(std::ostream&, const Stack<T>&);

private:

Node<T>* stkTop;
size_t stackSize;

public:
Stack();
~Stack();

Stack(const Stack<T>&);
Stack<T> & operator =(const Stack &);

void clear();
size_t size();
bool empty();

const T& top()const;
void push(const T&);
void pop();
void copyList(const Stack<T> &);
};
#endif

template <class T>
Stack<T>::Stack()
{
stkTop = NULL;
stackSize = 0;
}

template <class T>
Stack<T>::~Stack()
{
clear();
}

template <class T>
void Stack<T>::clear()
{
while(stackSize != 0)
{
pop();
}
}

template<class T>
void Stack<T>::pop()
{
Node<T>* delNode = stkTop;
stkTop = stkTop->next;

delete delNode;
stackSize--;
}

template <class T>
Stack<T> & Stack<T>::operator = (const Stack<T> & other)
{
if(this != &other)
{
clear();
stkTop = other.stkTop;
stackSize = other.stackSize;
}

return *this;
}

template <class T>
std::ostream& operator<<(std::ostream &leftObj, const Stack<T> &rightObj)
{
Node<T>* ptr;
for (ptr = rightObj.stkTop; ptr != NULL; ptr = ptr->next)
{
leftObj << ptr->data << ' ';
}

return leftObj;
}

template <class T>
size_t Stack<T>::size()
{
return stackSize;
}

template <class T>
bool Stack<T>::empty()
{
if(stackSize == 0)
{
return true;
}
else
{
return false;
}
}

template <class T>
const T& Stack<T>::top()const
{
return stkTop->data;
}

template <class T>
void Stack<T>::push(const T &other)
{
Node<T>* newNode = new Node<T>(other, stkTop);
stkTop = newNode;
stackSize++;
}

template <class T>
Stack<T>::Stack(const Stack<T> &other)
{
stkTop = NULL;
stkTop = other.stkTop;
stackSize = other.stackSize;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

TEST FILE

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

using std::cout;
using std::endl;

int main()
{
cout << "Testing default constructor\n\n";

Stack<int> s1;

cout << "s1 (size " << s1.size() << "): " << s1 << endl;
cout << "s1 is " << ((s1.empty()) ? "empty\n" : "not empty\n");
cout << endl;

cout << "Testing push()\n\n";

s1.push(17);

cout << "s1 (size " << s1.size() << "): " << s1 << endl;
cout << "s1 is " << ((s1.empty()) ? "empty\n" : "not empty\n");
cout << endl;

s1.push(2);
s1.push(6);
s1.push(4);

cout << "s1 (size " << s1.size() << "): " << s1 << endl;
cout << "s1 is " << ((s1.empty()) ? "empty\n" : "not empty\n");
cout << endl;

cout << "Testing copy constructor\n\n";
Stack<int> s2(s1);

cout << "s1 (size " << s1.size() << "): " << s1 << endl;
cout << "s2 (size " << s2.size() << "): " << s2 << endl << endl;

cout << "Testing clear()\n\n";
s1.clear();

cout << "s1 (size " << s1.size() << "): " << s1 << endl;
cout << "s2 (size " << s2.size() << "): " << s2 << endl << endl;

Stack<int> s3;

s3.push(36);
s3.push(41);
s3.push(75);
s3.push(28);

cout << "s3 (size " << s3.size() << "): " << s3 << endl << endl;

cout << "Testing assignment operator\n\n";

Stack<int> s4;

s4 = s3;

cout << "s3 (size " << s3.size() << "): " << s3 << endl;
cout << "s4 (size " << s4.size() << "): " << s4 << endl << endl;

s3.clear();

cout << "s3 (size " << s3.size() << "): " << s3 << endl;
cout << "s4 (size " << s4.size() << "): " << s4 << endl << endl;

cout << "Testing assignment to self\n\n";

s4 = s4;
s3 = s4;

s4.clear();

cout << "s3 (size " << s3.size() << "): " << s3 << endl;
cout << "s4 (size " << s4.size() << "): " << s4 << endl << endl;

Answer 1

#ifndef STACK_H
#define STACK_H

#include <iostream>

template <class T> struct Node
{
   T data;
   Node<T>* next;

   Node(const T& = T(), Node<T>* next = NULL);
};

template <class T>Node<T>::Node(const T& data, Node<T>* next)
{
   this->next = next;
   this->data = data;
}

template <class T> class Stack;

template <class T>std::ostream& operator<<(std::ostream&, const Stack<T>&);

template <class T>class Stack
{
   friend std::ostream& operator<< <>(std::ostream&, const Stack<T>&);

   private:

   Node<T>* stkTop;
   size_t stackSize;