I need help understanding Allen++ I never used it can some help? Pleassseeee.

The program should work by reading the name of the file to parse from the command line. SHOULD NOT prompt the user to enter the name of the file.

//Header file: stackADT.h

#ifndef H_StackADT

#define H_StackADT

template

class stackADT

{

public:

virtual void initializeStack() = 0;

//Method to initialize the stack to an empty state.

//Postcondition: Stack is empty

virtual bool isEmptyStack() const = 0;

//Function to determine whether the stack is empty.

//Postcondition: Returns true if the stack is empty,

// otherwise returns false.

virtual bool isFullStack() const = 0;

//Function to determine whether the stack is full.

//Postcondition: Returns true if the stack is full,

// otherwise returns false.

virtual void push(const Type& newItem) = 0;

//Function to add newItem to the stack.

//Precondition: The stack exists and is not full.

//Postcondition: The stack is changed and newItem

// is added to the top of the stack.

virtual Type top() const = 0;

//Function to return the top element of the stack.

//Precondition: The stack exists and is not empty.

//Postcondition: If the stack is empty, the program

// terminates; otherwise, the top element

// of the stack is returned.

virtual void pop() = 0;

//Function to remove the top element of the stack.

//Precondition: The stack exists and is not empty.

//Postcondition: The stack is changed and the top

// element is removed from the stack.

};

#endif

//Header file: myStack.h

#ifndef H_StackType

#define H_StackType

#include

#include

#include "stackADT.h"

using namespace std;

template

class stackType: public stackADT

{

public:

const stackType& operator=(const stackType&);

//Overload the assignment operator.

void initializeStack();

//Function to initialize the stack to an empty state.

//Postcondition: stackTop = 0

bool isEmptyStack() const;

//Function to determine whether the stack is empty.

//Postcondition: Returns true if the stack is empty,

// otherwise returns false.

bool isFullStack() const;

//Function to determine whether the stack is full.

//Postcondition: Returns true if the stack is full,

// otherwise returns false.

void push(const Type& newItem);

//Function to add newItem to the stack.

//Precondition: The stack exists and is not full.

//Postcondition: The stack is changed and newItem

// is added to the top of the stack.

Type top() const;

//Function to return the top element of the stack.

//Precondition: The stack exists and is not empty.

//Postcondition: If the stack is empty, the program

// terminates; otherwise, the top element

// of the stack is returned.

void pop();

//Function to remove the top element of the stack.

//Precondition: The stack exists and is not empty.

//Postcondition: The stack is changed and the top

// element is removed from the stack.

stackType(int stackSize = 100);

//constructor

//Create an array of the size stackSize to hold

//the stack elements. The default stack size is 100.

//Postcondition: The variable list contains the base

// address of the array, stackTop = 0, and

// maxStackSize = stackSize.

stackType(const stackType& otherStack);

//copy constructor

~stackType();

//destructor

//Remove all the elements from the stack.

//Postcondition: The array (list) holding the stack

// elements is deleted.

void print();

private:

int maxStackSize; //variable to store the maximum stack size

int stackTop; //variable to point to the top of the stack

Type *list; //pointer to the array that holds the

//stack elements

void copyStack(const stackType& otherStack);

//Function to make a copy of otherStack.

//Postcondition: A copy of otherStack is created and

// assigned to this stack.

};

template

void stackType::initializeStack()

{

stackTop = 0;

}//end initializeStack

template

bool stackType::isEmptyStack() const

{

return (stackTop == 0);

}//end isEmptyStack

template

bool stackType::isFullStack() const

{

return (stackTop == maxStackSize);

} //end isFullStack

template

void stackType::push(const Type& newItem)

{

if (!isFullStack())

{

list[stackTop] = newItem; //add newItem to the

//top of the stack

stackTop++; //increment stackTop

}

else

cout

}//end push

template

Type stackType::top() const

{

assert(stackTop != 0); //if stack is empty,

//terminate the program

return list[stackTop - 1]; //return the element of the

//stack indicated by

//stackTop - 1

}//end top

template

void stackType::pop()

{

if (!isEmptyStack())

stackTop--; //decrement stackTop

else

cout

}//end pop

template

stackType::stackType(int stackSize)

{

if (stackSize =>

{

cout

cout

maxStackSize = 100;

}

else

maxStackSize = stackSize; //set the stack size to

//the value specified by

//the parameter stackSize

stackTop = 0; //set stackTop to 0

list = new Type[maxStackSize]; //create the array to

//hold the stack elements

}//end constructor

template

stackType::~stackType() //destructor

{

delete [] list; //deallocate the memory occupied

//by the array

}//end destructor

template

void stackType::copyStack

(const stackType& otherStack)

{

delete [] list;

maxStackSize = otherStack.maxStackSize;

stackTop = otherStack.stackTop;

list = new Type[maxStackSize];

//copy otherStack into this stack

for (int j = 0; j

list[j] = otherStack.list[j];

} //end copyStack

template

stackType::stackType(const stackType& otherStack)

{

list = nullptr;

copyStack(otherStack);

}//end copy constructor

template

const stackType& stackType::operator=

(const stackType& otherStack)

{

if (this != &otherStack) //avoid self-copy

copyStack(otherStack);

return *this;

} //end operator=

template

void stackType::print()

{

if (!isEmptyStack())

{

for(int m=stackTop-1; m>=0; m--)

cout

}

}

#endif

/*

This Test program demonstrates:

1. How to get an argument from the command line when

executing a program

2. How to use ifstream to read tokens from a file using

the >> operator, which reads up until a

whitespace (newline, carriage return, tab)

3. How to define and use the Stack data structure

*/

#include

#include

#include "stack.h"

using namespace std;

int main(int argc, char* argv[])

{

if (argc

// Tell the user how to run the program

cout

return 1;

}

int a,b;

string filename = argv[1]; // get the filename from command line

ifstream sourcefile("data.txt"); // open file

stackType s;

// Read from a file using >> , which

// reads until a whitespace is encountered

cout

sourcefile >> a;

cout

sourcefile >> b;

cout

// Use a stack

s.push(6);

s.push(8);

s.push(4);

cout

cout

s.print();

return 0;

}