Question

我试图在堆栈满了后将其加倍。我试过调用复制构造函数，当我调用它时，堆栈不会继续推送单词。代码在它变满之前运行完美，但一旦它满了就是我的问题发生的地方。我做错了什么？

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

此外，我试图在push函数中调用复制构造函数，例如：

        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

Answer 1

自：

r1 = df1.reset_index(level=1, drop=1)
r2 = df2.reset_index(level=1, drop=1)

r = r2.sub(r1)

r
           time
patient_id        
A          15 days
B           3 days
C              NaT
D          13 days

要：

arrayStack<Type> newArrayStack(maxStackSize*2);
for(int i = 0; i < maxStackSize; i++){
      newArrayStack.push(list[i]);
}
newArrayStack.push(word);
stackCopy(newArrayStack);

在推送功能中尝试此操作，这将使堆栈的大小加倍。就像评论中提到的那样，你的拷贝构造函数和stackcopy函数中有错误

基于C ++数组的堆栈

1 个答案: