#ifndef H_StackType
#define H_StackType

#include <iostream>
#include <cassert>

using namespace std;

template<class Type>
class stackType
{
public:
    const stackType<Type>& operator=(const stackType<Type>&); 
      //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 destroyStack();
      //Function to remove all the elements from the stack.
      //Postcondition: stackTop = 0

    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 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<Type>& 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<Type>& otherStack); 
      //Function to make a copy of otherStack.
      //Postcondition: A copy of otherStack is created and
      //               assigned to this stack.
};


template<class Type>
void stackType<Type>::initializeStack()
{
	stackTop = 0;
}                                       //end initializeStack

template<class Type>
void stackType<Type>::destroyStack()
{
	stackTop = 0;
}                                       //end destroyStack

template<class Type>
bool stackType<Type>::isEmptyStack() const
{
	return(stackTop == 0);
}                                         //end isEmptyStack

template<class Type>
bool stackType<Type>::isFullStack() const
{
	return(stackTop == maxStackSize);
}                                        //end isFullStack

template<class Type>
void stackType<Type>::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<class Type>
Type stackType<Type>::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<class Type>
void stackType<Type>::pop()
{
	if (!isEmptyStack())
	    stackTop--;                               //decrement stackTop 
 	else
	   cout << "Cannot remove from an empty stack." << endl;
}                                                             //end pop

template<class Type>
stackType<Type>::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
	assert(list != NULL);
}                                                           //end constructor

template<class Type>
stackType<Type>::~stackType()               //destructor
{
   delete [] list;                          //deallocate the memory occupied 
                                               //by the array
}                                             //end destructor

template<class Type>
void stackType<Type>::copyStack(const stackType<Type>& otherStack)
{ 

 	delete [] list;				   
	maxStackSize = otherStack.maxStackSize;		   
  	stackTop = otherStack.stackTop;			   
	  
    list = new Type[maxStackSize];		   
	assert(list != NULL);			   

                                       //copy otherStack into this stack
    for (int j = 0; j < stackTop; j++)  
        list[j] = otherStack.list[j];
}                                    //end copyStack


template<class Type>
stackType<Type>::stackType(const stackType<Type>& otherStack)
{
	list = NULL;

	copyStack(otherStack);
}                                    //end copy constructor

template<class Type>
const stackType<Type>& stackType<Type>::operator=
   					(const stackType<Type>& otherStack)
{ 
   if (this != &otherStack)                 //avoid self-copy
 	  copyStack(otherStack);

   return *this; 
}                                            //end operator=         

template<class Type>
void stackType<Type>::reverseStack(stackType<Type> &otherStack)
{
   int j;

   if (stackTop > otherStack.maxStackSize)
   {
	   cout << "The size of other stack is less than the number of " << endl
		    << "elements currently in the stack." << endl;
	   cout << "This stack cannot be reversed." << endl;
   }
   else
   {
		otherStack.stackTop = stackTop;

	for (j = 0; j < stackTop; j++)   // copy other stack into this stack
	otherStack.list[j] = list[stackTop - 1 - j];
	}
}

#endif

#include <iostream>			
#include<stdio.h> 
#include<conio.h> 

#include "myStack.h"

using namespace std;

int main()
{
	stackType<int> stack1(50);
	stackType<int> stack2(50);

	stack1.initializeStack();
	stack1.push();
	stack1.push();
	stack1.push();
	stack1.push();
	stack1.push();
	stack1.push();

	cout << "stack1: ";

	while (!stack1.isEmptyStack())
	{
		cout << stack1.top() << " ";
		stack1.pop();
	}

	cout << endl;

	cout << "stack2: ";

	while (!stack2.isEmptyStack())
	{
		cout << stack2.top() << " ";
		stack2.pop();
	}

	cout << endl;

//find the prime factors of a number
cin << num;
int fact=2;
   while(num>1)
    {if((num%fact)==0)
    {push fact;num/=fact;)
     else {fact++;}} 


// print prime in between 2 -100

int primeFlag; 
int i,j; 
   clrscr(); 
   for (i = 2i<100;i++){ 
   primeFlag = 1; 
   for(j = 2; j<i/2+1 && primeFlag ; j++)  
{ 
    if(i%j==0 ) primeFlag=0; 
} 
       if(primeFlag)  
{ 
       printf(" %d ",i); 
    } 
}

// print factors of positive integers in descending order

int a1[100],i,z,j,s; 
clrscr(); 
printf("Enter 100 factors\n"); 
    for (i=2;i<100;i++) 
    { 
    scanf("%d",&a1[i]); 
    } 
for(i=2;i<9;i++) 
{ 
    for(j=i+1;j<100;j++) 
    { 
        if(a1[i]>a1[j]) 

return 0;
}