I am trying to double a stack once it gets full. I have tried calling the copy constructor, and when I call it the stack doesn't keep pushing words. The code run perfectly before it gets full, but once it gets full is where my problem occur. What am I doing wrong?
#include<iostream>
#include<fstream>
#include<string>
//#include "ArgumentManager.h"
#include "Stack.h"
using namespace std;
int main(int argc, char** argv){
//ArgumentManager am(argc, argv); //Instantiating parser for command line arguments
//ReAdInG tHe InPuT fIlE nAmE
//ifstream infile(am.get("A").c_str()); // file to read from, getting name from command line
//ofstream outfile(am.get("C").c_str()); // output file, getting name from command line
ifstream infile;
ofstream outfile;
arrayStack<string> firstStack(10);
arrayStack<string> secondStack(firstStack);
firstStack.stackInitialize();
infile.open("input.txt");
outfile.open("output.txt");
//iF tHe FiLe IsNt ReAd
if(!infile){
std::cout << "ErRor[Input file not Found] YoU hAd OnE jOb....ShAmE" << endl;
std::cout << "ExItInG PrOgRaM!!! GoOdByE" << endl;
return 0;
};
string tester; // to get the words
//READ FROM INFILE AND OUTPUT TO OUTFILE
while(infile >> tester){
for(int i = 0; i < tester.size(); ++i)
{ // CHECK IF A SPECIAL CHARACTER IS ON THE FILE
if(!((tester[i] >= 'a' && tester[i] <= 'z')||(tester[i] >= 'A' && tester[i]<= 'Z')))
{
tester[i] = '\0';
}
}
firstStack.push(tester);
};
while(!firstStack.stackIsEmpty())
{
string b = firstStack.top();
outfile << b << " ";
cout << b << " ";
if(firstStack.stackIsFull()){
secondStack.push(tester)
};
firstStack.pop();
}
infile.close();
outfile.close();
return 0;
}
Also I have tried to call the copy constructor in the push function such as:
template <class Type>
void arrayStack<Type>::push(const Type& word){
if(topStack != maxStackSize){
list[topStack] = word; // adding a new word to the STACK
topStack++;
}
else
cout << "YOU KNOW YOU CAN'T ADD TO A FULL STACK............SHAME" << endl;
arrayStack<Type> newArrayStack(maxStackSize*2);
for(int i = 0; i < maxStackSize; i++){
newArrayStack.push(list[i]);
}
newArrayStack.push(word);
stackCopy(newArrayStack);
}
It doesn't work either.
Below is the Stack Template
//ARRAY BASED STACK TEMPLATE
#ifndef H_ArrayStack
#define H_ArrayStack
#include <iostream>
using namespace std;
template <class Type>
class arrayStack{
private:
int maxStackSize; // the maximum height of the STACK
int topStack; // the top of the STACK
void stackCopy(const arrayStack<Type>& newArrayStack);
Type *list; // array based needs pointer to hold the stack element
public:
const arrayStack<Type>& operator=(const arrayStack<Type>&);
void stackInitialize(){ topStack = 0;}; //Ensure the array stack is empty
bool stackIsEmpty() const{return(topStack == 0);}; //check if stack is empty, is const so will not be messed with
bool stackIsFull() const{return topStack == maxStackSize;}; // just like line 8 except check if it is full
void push(const Type& word); // add a word to the array STACK
void pop(); //remove a word from the array and increment the top
Type top() const; //returns the top of the STACK
arrayStack(int size); //the default constructor
arrayStack(const arrayStack<Type>& newArrayStack); // the copy constructor which allows a new STACK
~arrayStack(){delete [] list;}; // it is an array so to ensure no memory leaks the stack must be deleted after use
};
template <class Type>
void arrayStack<Type>::push(const Type& word){
if(topStack != maxStackSize){
list[topStack] = word; // adding a new word to the STACK
topStack++;
}
else{
cout << "YOU KNOW YOU CAN'T ADD TO A FULL STACK............SHAME" << endl;
int size = maxStackSize;
maxStackSize *= 2;
Type *temp = new Type[maxStackSize]; // create temp and double the size of list
for(int i = 0; i < size; i++){ // copy over all the values
temp[i] = list[i];
}
delete [] list; // delete the list
list = temp; // point to the resized list
list[topStack] = word;
topStack++;
}
}
template <class Type>
void arrayStack<Type>::pop(){
if (!stackIsEmpty()){
topStack--;
}
}
template <class Type>
Type arrayStack<Type>::top() const{
if(topStack == 0){
return 0;
}
else
return list[topStack - 1];
}
template <class Type>
arrayStack<Type>::arrayStack(int size){
maxStackSize = size;
topStack = 0;
list = new Type[maxStackSize];
}
template <class Type>
void arrayStack<Type>::stackCopy(const arrayStack<Type>& newArrayStack){
maxStackSize = newArrayStack.maxStackSize;
topStack = newArrayStack.topStack;
list = new Type[maxStackSize];
for(int j = 0; j < topStack; j++)
list[j] = newArrayStack.list[j];
}
template <class Type>
arrayStack<Type>::arrayStack(const arrayStack<Type>& newArrayStack){
stackCopy(newArrayStack);
}
template <class Type>
const arrayStack<Type>& arrayStack<Type>::operator=(const arrayStack<Type>& newArrayStack){
if(this != &newArrayStack)
stackCopy(newArrayStack);
return *this;
}
#endif
