Implement a new ITERATOR class (with at bare minimum a ++ and * operation) for the array-based stack. Follow the pattern used to create an iterator for the array-based list.

Finally, modify the main function to show the use of the iterator (add a for loop that uses an iterator to display all the elements of the stack from top to bottom, BUT does not modify the stack itself). All the files should be combined in a project. Please provide all the files here.

 BEGIN WITH THIS CODE for an array-based implementation of a stack //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. 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 << "Cannot add to a full stack." << endl; }//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 << "Cannot remove from an empty stack." << endl; }//end pop template  stackType::stackType(int stackSize) { if (stackSize <= 0) { cout << "Size of the array to hold the stack must " << "be positive." << endl; cout << "Creating an array of size 100." << endl; 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 < stackTop; 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= #endif