C++在我自己的堆栈类中的奇怪行为

这是一个包含我的Stack类和其他一些函数的程序。

ReadTheFile()—读取存储在num_file.txt中的数字，并返回包含这些数字的矢量
IntervalCheck()-将输入向量中特定范围的数字相加，并仅返回具有这些数字的向量

VecToMyStack()—将矢量中的数字添加到堆栈中。

#include <iostream>
#include <string>
#include <vector>
#include <fstream>
#define STACK_EMPTY -1
#define OUT_OF_STACK -2
using namespace std;
template <class T>
class Stack {
private:
    struct Node{
        T element;
        Node *prevElement;
    };
    size_t NumberOfElements;
    Node *tempAdr;
    Node *topElement;
    Node *newElement;
    Node *erasedElement;
public:
    Stack(){
        topElement = new Node;
        topElement->prevElement = nullptr;
        NumberOfElements = 0;
    }
    ~Stack(){
        cout << endl << "I'm a destructor";
    while(NumberOfElements !=0 ){
        tempAdr = topElement->prevElement;
        delete topElement;
        topElement = tempAdr;
        NumberOfElements--;
    }
    delete topElement;
    }
    void push(T input_element){
        tempAdr = topElement;
        topElement = new Node;
        topElement->element = input_element;
        topElement->prevElement = tempAdr;
        NumberOfElements++;
    }
    void pop(){
        if (NumberOfElements == 0) throw STACK_EMPTY;
        else {
            tempAdr = topElement->prevElement;
            delete topElement;
            topElement = tempAdr;
            NumberOfElements--;
        }
    }
    T top(){
        return NumberOfElements != 0 ? topElement->element : throw STACK_EMPTY;
    }
    void insert(size_t position, T input_element){
        if (position >= NumberOfElements) throw OUT_OF_STACK;
        else {
            tempAdr = topElement;
            for (size_t i = 0; i < position; i++){
                tempAdr = tempAdr->prevElement;
            }
            newElement = new Node;
            newElement->element = input_element;
            newElement->prevElement = tempAdr->prevElement;
            tempAdr->prevElement = newElement;
            NumberOfElements++;
        }
    }
    void erase(size_t position){
        if (position >= (NumberOfElements-1)) throw OUT_OF_STACK;
        else{
            tempAdr = topElement;
            for (size_t i = 0; i < position; i++){
                tempAdr = tempAdr->prevElement;
            }
            erasedElement = tempAdr->prevElement;
            tempAdr->prevElement = tempAdr->prevElement->prevElement;
            delete erasedElement;
            NumberOfElements--;
        }
    }
    void print(){
        if (NumberOfElements != 0){
            tempAdr = topElement;
            for (size_t i = 0; i < NumberOfElements; i++){
                cout << tempAdr->element << " ";
                tempAdr = tempAdr->prevElement;
            }
        }
    }
    size_t size() { return NumberOfElements; }

};

vector<int> ReadTheFile() { 
    vector<int> vec_from_file;
    int buffer;
    ifstream basefile;
    basefile.open("num_file.txt", ios::in); 
    if (basefile.is_open()) {   
        do {
            if (basefile >> buffer) 
                vec_from_file.push_back(buffer); 
            else { 
                basefile.clear(); 
                basefile.ignore(1, ' '); 
            }
        } while (!basefile.eof());  
        basefile.close();
    }
    else cout << "Unable to open file" << endl;
    return vec_from_file; 
}

vector<int> IntervalCheck(vector<int> vec_for_check){ 
    vector<int> out_vec;
    if (vec_for_check.empty()) cout << "There is nothing to check"; 
    else {
        int begin_int, end_int;
        do {
            cin.clear(); 
            cin.sync(); 
            cout << "Input the first and the last value of the interval: ";
            cin >> begin_int >> end_int;
        } while (cin.fail()); 
        for (auto &k : vec_for_check) 
            if (k > begin_int && k < end_int)
                out_vec.push_back(k); 
    }
    return out_vec; 
}

Stack<int> VecToMyStack(vector<int> input_vec){
    Stack<int> output_st;
    if (input_vec.empty()) {
        cout << "the end";
    }
    else {
        for (auto &k : input_vec){
            output_st.push(k);
        }
    }
    return output_st;
}
int main(){
    int choice = 0;
    do {
        cin.clear();
        cin.sync();
        VecToMyStack(IntervalCheck(ReadTheFile())).print();
        cout << "Would you like to measure another interval? 1-yes 2-no";
        cin >> choice;
    } while (choice == 1);
    system("pause");
    return 0;
}

整个程序应该使用类的print()方法将数字从文件推送到堆栈，并打印该堆栈。例如，如果存在具有的num_file.txt

0 1 2 3 4 5 6 7 8 9 10

在内部，该程序预计将以这种方式工作：

输入间隔的第一个和最后一个值：0 10/*零和10个由用户输入*/
1 2 3 4 5 6 7 8 9
你想测量另一个间隔吗？1-是2-否

但当VecToMyStack(IntervalCheck(ReadTheFile())).print();行被执行时，我得到了

访问违规读取位置0xFEEEFEEE

例外。看起来我的Stack类的析构函数在print()函数之前运行。为什么会发生这种情况？有什么特别的东西我应该添加到我的Stack类或VecToMyStack()函数中吗？

最后，经过几个小时的研究，我得到了缺失的代码：

Stack(const Stack &object){
        tempAdr = object.topElement;
        T * tempMas=new T[object.NumberOfElements];
        for (size_t i = 0; i < object.NumberOfElements; i++){
            tempMas[i] = tempAdr->element;
            tempAdr = tempAdr->prevElement;
        }
        topElement = new Node;
        topElement->prevElement = nullptr;
        NumberOfElements = 0;
        for (int i = object.NumberOfElements - 1; i >= 0; i--){
            push(tempMas[i]);
        }
        delete[] tempMas;
    }

我知道，如果没有重载的赋值运算符，我的Stack类仍然不完整，但至少我的代码运行良好。

相关内容

最新更新

热门标签：