Notes

main.cpp
#include<iostream>
#include <fstream>
#include "DynamicStack.h"
using namespace std;
int main() {
fstream file1("myFile1.txt", ios::in);
fstream file2("myFile2.txt", ios::out);
DynamicStack<char> stack;
char catchchar,ch;

file1.get(catchchar);
while(!file1.eof()){
stack.push(catchchar);
file1.get(catchchar);
}
file1.close();

while(!stack.isEmpty()){
stack.pop(ch);
file2.put(ch);
}

file2.close();
file2.open("myFile2.txt",ios::in);
file2.get(ch);
while(!file2.eof()){
cout<<ch;
file2.get(ch);
}
file2.close();
return 0;
}

dynamicstack.h
#ifndef DYNAMICSTACK_H
#define DYNAMICSTACK_H
#include <iostream>
using namespace std;

// Stack template
template <class T>
class DynamicStack
{
private:
// Structure for the stach nodes
struct StackNode
{
T value; // Value in the node
StackNode *next; // Pointer to next node
};

StackNode *top; // Pointer to the stack top

public:
//Constructor
DynamicStack()
{ top = NULL; }

// Destructor
~DynamicStack();

// Stack operations
void push(T);
void pop(T &);
bool isEmpty();
};

//***************************************************
// Destructor *
//***************************************************
template <class T>
DynamicStack<T>::~DynamicStack()
{
StackNode *nodePtr, *nextNode;

// Position nodePtr at the top of the stack.
nodePtr = top;

// Traverse the list deleting each node.
while (nodePtr != NULL)
{
nextNode = nodePtr->next;
delete nodePtr;
nodePtr = nextNode;
}
}

//*************************************************************
// Member function push pushes the argument onto *
// the stack. *
//*************************************************************

template <class T>
void DynamicStack<T>::push(T item)
{
StackNode *newNode; // Pointer to a new node

// Allocate a new node and store num there.
newNode = new StackNode;
newNode->value = item;

// If there are no nodes in the list
// make newNode the first node.
if (isEmpty())
{
top = newNode;
newNode->next = NULL;
}
else // Otherwise, insert NewNode before top.
{
newNode->next = top;
top = newNode;
}
}

//*************************************************************
// Member function pop pops the value at the top *
// of the stack off, and copies it into the variable *
// passed as an argument. *
//*************************************************************

template <class T>
void DynamicStack<T>::pop(T &item)
{
StackNode *temp; // Temporary pointer

// First make sure the stack isn't empty.
if (isEmpty())
{
cout << "The stack is empty.n";
}
else // pop value off top of stack
{
item = top->value;
temp = top->next;
delete top;
top = temp;
}
}

//*************************************************************
// Member function isEmpty returns true if the stack *
// is empty, or false otherwise. *
//*************************************************************

template <class T>
bool DynamicStack<T>::isEmpty()
{
bool status;

if (!top)
status = true;
else
status = false;

return status;
}
#endif


dynamicqueue.h
#ifndef DYNAMICQUEUE_H
#define DYNAMICQUEUE_H
#include <iostream>
using namespace std;

// DynamicQueue template
template <class T>
class DynamicQueue
{
private:
// Structure for the queue nodes
struct QueueNode
{
T value; // Value in a node
QueueNode *next; // Pointer to the next node
};

QueueNode *front; // The front of the queue
QueueNode *rear; // The rear of the queue
int numItems; // Number of items in the queue
public:
// Constructor
DynamicQueue();

// Destructor
~DynamicQueue();

// Queue operations
void enqueue(T);
void dequeue(T &);
bool isEmpty() const;
bool isFull() const;
void clear();
};

//********************************************
// The constructor creates an empty queue. *
//********************************************
template <class T>
DynamicQueue<T>::DynamicQueue()
{
front = NULL;
rear = NULL;
numItems = 0;
}

//********************************************
// Destructor *
//********************************************
template <class T>
DynamicQueue<T>::~DynamicQueue()
{
clear();
}

//********************************************
// Function enqueue inserts the value in num *
// at the rear of the queue. *
//********************************************
template <class T>
void DynamicQueue<T>::enqueue(T item)
{
QueueNode *newNode;

// Create a new node and store num there.
newNode = new QueueNode;
newNode->value = item;
newNode->next = NULL;

// Adjust front and rear as necessary.
if (isEmpty())
{
front = newNode;
rear = newNode;
}
else
{
rear->next = newNode;
rear = newNode;
}

// Update numItems.
numItems++;
}

//**********************************************
// Function dequeue removes the value at the *
// front of the queue, and copies it into num. *
//**********************************************
template <class T>
void DynamicQueue<T>::dequeue(T &item)
{
QueueNode *temp;

if (isEmpty())
{
cout << "The queue is empty.n";
}
else
{
// Save the front node value in num.
item = front->value;

// Remove the front node and delete it.
temp = front;
front = front->next;
delete temp;

// Update numItems.
numItems--;
}
}

//*********************************************
// Function isEmpty returns true if the queue *
// is empty, and false otherwise. *
//*********************************************
template <class T>
bool DynamicQueue<T>::isEmpty() const
{
bool status;

if (numItems > 0)
status = false;
else
status = true;
return status;
}

//********************************************
// Function clear dequeues all the elements *
// in the queue. *
//********************************************
template <class T>
void DynamicQueue<T>::clear()
{
T value; // Dummy variable for dequeue

while(!isEmpty())
dequeue(value);
}
#endif

main.cpp for dynamicqueue

#include <iostream>
#include <fstream>
#include "DynamicQueue.h"
using namespace std;
int main(){
fstream file1("myFile1.txt",ios::in);
fstream file2("myFile2.txt",ios::out);
char catchchar,ch;
DynamicQueue<char> queue;
file1.get(catchchar);
while(!file1.eof()){
queue.enqueue(catchchar);
file1.get(catchchar);
}
file1.close();
while(!queue.isEmpty()){
queue.dequeue(ch);
file2.put(ch);
}
file2.close();
file2.open("myFile2.txt",ios::in);
file2.get(ch);
while(!file2.eof()){
cout<<ch;
file2.get(ch);
}
file2.close();
}