Question

// thanks for helping

// C++ homework

// The homework is to complete below in the stack.h :
//    1. the copy constructor
//    2. the assignment operator
//     3. the destructor
//    4. Write a test program (mytest.cpp) to test copy and assignment
//    5. Verify destructor by running the test program in Valgrind


// This is the main.cpp

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

using namespace std;

int main() {
  Stack<int> intStack;

  cout << "\nPush integers on stack and dump contents:\n";
  for (int i = 1; i <= 10; i++) {
    intStack.push(i);
  }

  intStack.dump();

  cout << "\nRead contents using top() and pop():\n";
  while ( not intStack.empty() ) {
    cout << intStack.top() << endl;
    intStack.pop();
  }

  cout << "\nAttempt pop() of empty stack:\n";
  try {
    intStack.pop();
  } catch (exception &e) {
    cout << "Caught exception:\n" << e.what() << endl;
  }

  return 0;
}

// This is stack.h

#ifndef _STACK_H
#define _STACK_H

#include <iostream>
#include <exception>

using std::ostream;
using std::cout;
using std::endl;
using std::range_error;

// Forward declarations
template <class T> class Stack;
template <class T> class Node;
template <class T> ostream& operator<<(ostream&, const Node<T>&);

// Node class for linked list
template <class T>
class Node {

  friend Stack<T>;
  
public:
  Node(T data = T(), Node<T> *next = nullptr) {
    _data = data;
    _next = next;
  }

  friend ostream& operator<< <T>(ostream &sout, const Node<T> &x);
  
private:
  T _data;
  Node *_next;
};

// Overloaded insertion operator.  Must be overloaded for the template
// class T, or this won't work!
template <class T>
ostream& operator<<(ostream &sout, const Node<T> &x) {
  sout << "Data: " << x._data;
  return sout;
}


// Stack class.  Linked-list implementation of a stack. Uses the Node
// class.
template <class T>
class Stack {
public:
  // Constructor
  Stack();

  // Copy constructor, assignment operator, and destructor
  // DO NOT IMPLEMENT HERE.  SEE BELOW.
  Stack(const Stack &rhs);
  const Stack& operator=(const Stack& rhs);
  ~Stack();

  // Stack operations: push(), top(), and pop()
  void push(const T& data);
  const T& top() const;
  void pop();

  // Helpful functions
  bool empty() const;  // Returns 'true' if stack is empty
  void dump() const;   // Dump contents of the linked list

private:
  Node<T> *_head;

  // ***************************************************
  // Any private helper functions must be delared here!
  // ***************************************************
  
};

template <class T>
Stack<T>::Stack() {
  _head = nullptr;
}

template <class T>
Stack<T>::Stack(const Stack<T>& rhs) {

  // ********************************
  // Implement the copy constructor
  // ********************************
  
}

template <class T>
const Stack<T>& Stack<T>::operator=(const Stack<T>& rhs) {

  // **********************************
  // Implement the assignment operator
  // **********************************
  
}

template <class T>
Stack<T>::~Stack() {

  // *************************
  // Implement the destructor
  // *************************
  
}

template <class T>
void Stack<T>::push(const T& data) {
  Node<T> *tmpPtr = new Node<T>(data);
  tmpPtr->_next = _head;
  _head = tmpPtr;
}

template <class T>
const T& Stack<T>::top() const {
  if ( empty() ) {
    throw range_error("Stack<T>::top(): attempt to read empty stack.");
  }

  return _head->_data;
}

template <class T>
void Stack<T>::pop() {
  if ( empty() ) {
    throw range_error("Stack<T>::pop(): attempt to pop from an empty stack.");
  }

  Node<T> *tmpPtr = _head->_next;
  delete _head;
  _head = tmpPtr;
}

template <class T>
bool Stack<T>::empty() const {
  return _head == nullptr;
}

template <class T>
void Stack<T>::dump() const {
  Node<T> *nodePtr = _head;
  while ( nodePtr != nullptr ) {
    cout << nodePtr->_data << endl;
    nodePtr = nodePtr->_next;
  }
}

#endif

Answer 1

// stack.h

#ifndef _STACK_H
#define _STACK_H

#include <iostream>
#include <exception>

using std::ostream;
using std::cout;
using std::endl;
using std::range_error;

// Forward declarations
template <class T> class Stack;
template <class T> class Node;
template <class T> ostream& operator<<(ostream&, const Node<T>&);

// Node class for linked list
template <class T>
class Node {

friend Stack<T>;

public:
Node(T data = T(), Node<T> *next = nullptr) {
_data = data;
_next = next;
}

friend ostream& operator<< <T>(ostream &sout, const Node<T> &x);

private:
T _data;
Node *_next;
};

// Overloaded insertion operator. Must be overloaded for the template
// class T, or this won't work!
template <class T>
ostream& operator<<(ostream &sout, const Node<T> &x) {
sout << "Data: " << x._data;
return sout;
}

// Stack class. Linked-list implementation of a stack. Uses the Node
// class.
template <class T>
class Stack {
public:
// Constructor
Stack();

// Copy constructor, assignment operator, and destructor
// DO NOT IMPLEMENT HERE. SEE BELOW.
Stack(const Stack &rhs);
const Stack& operator=(const Stack& rhs);
~Stack();

// Stack operations: push(), top(), and pop()
void push(const T& data);
const T& top() const;
void pop();

// Helpful functions
bool empty() const; // Returns 'true' if stack is empty
void dump() const; // Dump contents of the linked list

private:
Node<T> *_head;

// ***************************************************
// Any private helper functions must be delared here!
// ***************************************************
void copyStack(const Stack &rhs); // helper function to copy the contents of rhs
};

template <class T>
Stack<T>::Stack() {
_head = nullptr;
}

template <class T>
Stack<T>::Stack(const Stack<T>& rhs) {

   _head = nullptr; // set head to null
   copyStack(rhs); // copy contents of rhs to this stack
}

template <class T>
const Stack<T>& Stack<T>::operator=(const Stack<T>& rhs) {

   if(this != &rhs) // check for self assignment
   {
       // delete the existing contents of the stack
       while(_head != nullptr)
       {
           Node<T> *tmp = _head;
           _head = _head->_next;
           delete(tmp);
       }

       copyStack(rhs); // copy the contents of rhs to this stack
   }

   return *this;
}

template <class T>
Stack<T>::~Stack() {

   // loop to delete the contents of the stack
   while(_head != nullptr)
   {
       Node<T> *tmp = _head;
       _head = _head->_next;
       delete(tmp);
   }
}

// function to copy the contents of rhs
template <class T>
void Stack<T>:: copyStack(const Stack &rhs)
{
   Node<T> *node = rhs._head; // set node to point to head of rhs
   Node<T> *tmp = _head; // set tmp to head of this stack

   // loop to copy the nodes of rhs to this stack
   while(node != nullptr)
   {
       // if empty stack
       if(tmp == nullptr)
       {
           _head = new Node<T>(node->_data); // create a new node for head
           tmp = _head; // set tmp to head
       }
       else // if non-empty stack
       {
           tmp->_next = new Node<T>(node->_data); // create a new node for node next to tmp
           tmp = tmp->_next; // make tmp point to the above created node
       }

       node = node->_next; // point node to next node of rhs
   }
}

template <class T>
void Stack<T>::push(const T& data) {
Node<T> *tmpPtr = new Node<T>(data);
tmpPtr->_next = _head;
_head = tmpPtr;
}

template <class T>
const T& Stack<T>::top() const {
if ( empty() ) {
throw range_error("Stack<T>::top(): attempt to read empty stack.");
}

return _head->_data;
}

template <class T>
void Stack<T>::pop() {
if ( empty() ) {
throw range_error("Stack<T>::pop(): attempt to pop from an empty stack.");
}

Node<T> *tmpPtr = _head->_next;
delete _head;
_head = tmpPtr;
}

template <class T>
bool Stack<T>::empty() const {
return _head == nullptr;
}

template <class T>
void Stack<T>::dump() const {
Node<T> *nodePtr = _head;
while ( nodePtr != nullptr ) {
cout << nodePtr->_data << endl;
nodePtr = nodePtr->_next;
}
}

#endif

//end of stack.h

// main.cpp : C++ program to test the Stack class

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

using namespace std;

int main() {
Stack<int> intStack;

cout << "\nPush integers on stack and dump contents:\n";
for (int i = 1; i <= 10; i++) {
intStack.push(i);
}

intStack.dump();

// test the copy constructor and assignment operator
Stack<int> cStack(intStack), aStack;
cout<<"Stack using copy constructor:"<<endl;
cStack.dump();

cout<<"Stack using assignment operator:"<<endl;
aStack = cStack;
aStack.dump();

cout << "\nRead contents using top() and pop():\n";
while ( not intStack.empty() ) {
cout << intStack.top() << endl;
intStack.pop();
}

cout << "\nAttempt pop() of empty stack:\n";
try {
intStack.pop();
} catch (exception &e) {
cout << "Caught exception:\n" << e.what() << endl;
}

return 0;
}

//end of main.cpp

Output: