C++基于阵列的堆栈

一旦堆栈已满，我正在尝试将堆栈加倍。我尝试调用复制构造函数，当我调用它时，堆栈不会继续推送单词。代码在满载之前完美运行，但一旦填满就是我出现问题的地方。我做错了什么？

    #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] = '';
                    }
            }
            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;
    }

我还尝试在推送函数中调用复制构造函数，例如：

        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);
    }

它也不起作用。

下面是堆栈模板

   
        //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