Return to Answer

###Looking at node

##looking at stack

###General Comments

Looking at node

looking at stack

General Comments

#ifndef STACK_H
#define STACK_H
#include <iostream>
template <typename T>
class Stack {
 struct Node { 
 T data;
 Node* next;
 Node(T const& data, Node* next)
 : data(data)
 , next(next)
 {}
 Node(T&& data, Node* next) // With C++11 allow move construction
 : data(std::move(data))
 , next(next)
 {}
 };
 public:
 ~Stack();
 void push(T const& data);
 void push(T&& data); // WIth C++ 11 allow move construction
 bool empty() const;
 int size() const;
 T top() const;
 void pop();
 void print(std::ostream& str = std::cout) const;
 private:
 Node* root = nullptr;
 int elements = 0;
};
template<typename T>
void Stack<T>::~Stack()
{
 Node* next;
 for(Node* loop = root; loop != nullptr; loop = next)
 {
 next = loop->next;
 delete loop;
 }
}
template<typename T>
void Stack<T>::push(T const& data)
{
 root = new Node(data, root);
 ++elements;
}
template<typename T>
void Stack<T>::push(T&& data)
{
 root = new Node(std::forward(data), root);
 ++elements;
}
template<typename T>
bool Stack<T>::empty() const
{
 return root == nullptr;
}
template<typename T>
int Stack<T>::size() const
{
 return elements;
}
template<typename T>
T Stack<T>::top() const
{
 if (root == nullptr)
 { throw std::runtime_error("Invalid Action");
 }
 return root->data;
}
template<typename T>
void Stack<T>::pop()
{
 if (root == nullptr)
 { throw std::runtime_error("Invalid Action");
 }
 Node* tmp = root;
 root = root->next;
 --elements;
 delete tmp;
}
template<typename T>
void Stack<T>::print(std::ostream& str) const
{
 int id = 0;
 for(Node* loop=root; loop != nullptr; loop=loop->next, ++id)
 {
 str << "Element: " << id << " = " << loop->data << "\n";
 }
}
#endif

#ifndef STACK_H
#define STACK_H
#include <iostream>
#include <stdexcept>

template <typename T>
class Stack {
 struct Node { 
 T data;
 Node* next;
 Node(T const& data, Node* next)
 : data(data)
 , next(next)
 {}
 Node(T&& data, Node* next) // With C++11 allow move construction
 : data(std::move(data))
 , next(next)
 {}
 };
 public:
 ~Stack();
 void push(T const& data);
 void push(T&& data); // WIth C++ 11 allow move construction
 bool empty() const;
 int size() const;
 T top() const;
 void pop();
 void print(std::ostream& str = std::cout) const;
 private:
 Node* root = nullptr;
 int elements = 0;
};
template<typename T>
Stack<T>::~Stack()
{
 Node* next;
 for(Node* loop = root; loop != nullptr; loop = next)
 {
 next = loop->next;
 delete loop;
 }
}
template<typename T>
void Stack<T>::push(T const& data)
{
 root = new Node(data, root);
 ++elements;
}
template<typename T>
void Stack<T>::push(T&& data)
{
 root = new Node(std::forward(data), root);
 ++elements;
}
template<typename T>
bool Stack<T>::empty() const
{
 return root == nullptr;
}
template<typename T>
int Stack<T>::size() const
{
 return elements;
}
template<typename T>
T Stack<T>::top() const
{
 if (root == nullptr)
 { throw std::runtime_error("Invalid Action");
 }
 return root->data;
}
template<typename T>
void Stack<T>::pop()
{
 if (root == nullptr)
 { throw std::runtime_error("Invalid Action");
 }
 Node* tmp = root;
 root = root->next;
 --elements;
 delete tmp;
}
template<typename T>
void Stack<T>::print(std::ostream& str) const
{
 int id = 0;
 for(Node* loop=root; loop != nullptr; loop=loop->next, ++id)
 {
 str << "Element: " << id << " = " << loop->data << "\n";
 }
}
#endif

#ifndef STACK_H
#define STACK_H
#include <iostream>
template <typename T>
class Stack {
 struct Node { 
 T data;
 Node* next;
 Node(T const& data, Node* next)
 : data(data)
 , next(next)
 {}
 Node(T&& data, Node* next) // With C++11 allow move construction
 : data(std::move(data))
 , next(next)
 {}
 };
 public:
 ~Stack();
 void push(T const& data);
 void push(T&& data); // WIth C++ 11 allow move construction
 bool empty() const;
 int size() const;
 T top() const;
 void pop();
 void print(std::ostream& str = std::cout) const;
 private:
 Node* root = nullptr;
 int elements = 0;
};
template<typename T>
void Stack<T>::~Stack()
{
 Node* next;
 for(Node* loop = root; root != nullptr; loop = next)
 {
 next = loop->next;
 delete loop;
 }
}
template<typename T>
void Stack<T>::push(T const& data)
{
 root = new Node(data, root);
 ++elements;
}
template<typename T>
void Stack<T>::push(T&& data)
{
 root = new Node(std::forward(data), root);
 ++elements;
}
template<typename T>
bool Stack<T>::empty() const
{
 return root == nullptr;
}
template<typename T>
int Stack<T>::size() const
{
 return elements;
}
template<typename T>
T Stack<T>::top() const
{
 if (root == nullptr)
 { throw std::runtime_error("Invalid Action");
 }
 return root->data;
}
template<typename T>
void Stack<T>::pop()
{
 if (root == nullptr)
 { throw std::runtime_error("Invalid Action");
 }
 Node* tmp = root;
 root = root->next;
 --elements;
 delete tmp;
}
template<typename T>
void Stack<T>::print(std::ostream& str) const
{
 int id = 0;
 for(Node* loop=root; loop != nullptr; loop=loop->next, ++id)
 {
 str << "Element: " << id << " = " << loop->data << "\n";
 }
}
#endif

#ifndef STACK_H
#define STACK_H
#include <iostream>
template <typename T>
class Stack {
 struct Node { 
 T data;
 Node* next;
 Node(T const& data, Node* next)
 : data(data)
 , next(next)
 {}
 Node(T&& data, Node* next) // With C++11 allow move construction
 : data(std::move(data))
 , next(next)
 {}
 };
 public:
 ~Stack();
 void push(T const& data);
 void push(T&& data); // WIth C++ 11 allow move construction
 bool empty() const;
 int size() const;
 T top() const;
 void pop();
 void print(std::ostream& str = std::cout) const;
 private:
 Node* root = nullptr;
 int elements = 0;
};
template<typename T>
void Stack<T>::~Stack()
{
 Node* next;
 for(Node* loop = root; loop != nullptr; loop = next)
 {
 next = loop->next;
 delete loop;
 }
}
template<typename T>
void Stack<T>::push(T const& data)
{
 root = new Node(data, root);
 ++elements;
}
template<typename T>
void Stack<T>::push(T&& data)
{
 root = new Node(std::forward(data), root);
 ++elements;
}
template<typename T>
bool Stack<T>::empty() const
{
 return root == nullptr;
}
template<typename T>
int Stack<T>::size() const
{
 return elements;
}
template<typename T>
T Stack<T>::top() const
{
 if (root == nullptr)
 { throw std::runtime_error("Invalid Action");
 }
 return root->data;
}
template<typename T>
void Stack<T>::pop()
{
 if (root == nullptr)
 { throw std::runtime_error("Invalid Action");
 }
 Node* tmp = root;
 root = root->next;
 --elements;
 delete tmp;
}
template<typename T>
void Stack<T>::print(std::ostream& str) const
{
 int id = 0;
 for(Node* loop=root; loop != nullptr; loop=loop->next, ++id)
 {
 str << "Element: " << id << " = " << loop->data << "\n";
 }
}
#endif