调试断言失败！表达式：is_block_type_valid(header->_block_use)

Question

Debug Assertion Failed!

Program: ...nts\Visual Studio 2015\Projects\Project 5\Debug\Project 5.exe
File: minkernel\crts\ucrt\src\appcrt\heap\debug_heap.cpp
Line: 892

Expression: is_block_type_valid(header->_block_use)

For information on how your program can cause an assertion
failure, see the Visual C++ documentation on asserts.

(Press Retry to debug the application)

程序运行并正确输出所有内容，并抛出此错误。我还没有找到任何关于这意味着什么或如何去寻找或修复它的好的解释。这是（令人难以置信的丑陋和糟糕的）代码的完整副本：

#include <iostream>
using namespace std;

/* a class for storing a Binary Tree */
template <class Type>
class BinaryTree {
protected:
    Type parentArray[10];
    Type childArray[10];
public:
    BinaryTree();
    BinaryTree(int& k);
    ~BinaryTree();
    BinaryTree(BinaryTree<Type>& bt);
    void operator= (BinaryTree<Type>& bt);
    friend ostream& operator<< (ostream& s, BinaryTree<Type> bt) {
        s << "[ ";
        bt.inorder(bt.getRoot());
        s << "]" << endl;
        return s;
    };
    int size();
    int height();
    int getLeft(int k);
    int getRight(int k);
    void preorder(int k);
    void inorder(int k) {

        // do I have a left child?
        if ((getLeft(k)) != -1) {
            // if yes inorder (left child)
            inorder(getLeft(k));
        };
        // output k
        cout << k << " ";
        // do I have a right child?
        if ((getRight(k)) != -1) {
            // if yes inorder (right child)
            inorder(getRight(k));
        };
    };
    void postorder(int k);
    void setRoot(Type& val);
    void setParent(Type* child, Type* parent);
    void setLeft(Type& val);
    void setRight(Type& val);
    int getRoot();
};

/* default constructor */
template <class Type>
BinaryTree<Type>::BinaryTree() {
    parentArray = new ArrayClass<Type>();
    childArray = new ArrayClass<Type>();
};

/* non-empty constructor */
template <class Type>
BinaryTree<Type>::BinaryTree(int& k) {
//  parentArray = new Type[k];
//  childArray = new Type[k];
};

template <class Type>
BinaryTree<Type>::~BinaryTree() {
    delete[] parentArray;
    delete[] childArray;
};

template <class Type>
BinaryTree<Type>::BinaryTree(BinaryTree<Type>& bt) {
    for (int i = 0; i < bt.size(); i++) {
        parentArray[i] = bt.parentArray[i];
        childArray[i] = bt.childArray[i];
    };
};

template <class Type>
void BinaryTree<Type>::operator= (BinaryTree<Type>& bt) {

};


/* return the size of the tree using the length of the parent array */
template <class Type>
int BinaryTree<Type>::size() {

    return (sizeof(parentArray)/sizeof(*parentArray));
};


template <class Type>
int BinaryTree<Type>::height() {
    return 5;
};

template <class Type>
int BinaryTree<Type>::getLeft(int k) {

    // if the parent array value of the given number is k and 
    // the child array value indicates it is a left child
    for (int i = 0; i < size(); i++) {
        if ((parentArray[i] == k) && (childArray[i] == 0)) {

            // return that value
            return i;
        };
    };
    return -1;
};

template <class Type>
int BinaryTree<Type>::getRight(int k) {

    // if the parent array value of the given number is k and 
    // the child array value indicates it is a right child
    for (int i = 0; i < size(); i++) {
        if ((parentArray[i] == k) && (childArray[i] == 1)) {

            // return that value
            return i;
        };
    };
    return -1;
};

template <class Type>
void BinaryTree<Type>::preorder(int k) {
    // output k
    cout << k << " ";
    // do I have a left child?
    if ((getLeft(k)) != -1) {
        // if yes preorder left child
        preorder(getLeft(k));
    };
    // do I have a right child?
    if ((getRight(k)) != -1) {
        // if yes preorder right child
        preorder(getRight(k));
    };
};

template <class Type>
void BinaryTree<Type>::postorder(int k) {
    // do I have a left child?
    if ((getLeft(k)) != -1) {
        // if yes inorder (left child)
        inorder(getLeft(k));
    };
    // do I have a right child?
    if ((getRight(k)) != -1) {
        // if yes inorder (right child)
        inorder(getRight(k));
    };
    // output k
    cout << k << " ";
};

template <class Type>
void BinaryTree<Type>::setRoot(Type& val) {
    // if the given value is the root of the tree then set
    // its index in the parent and child arrays to -1
    parentArray[val] = -1;
    childArray[val] = -1;
};

template <class Type>
void BinaryTree<Type>::setParent(Type* child, Type* parent) {

    // set a given value as the parent of a given value
    parentArray[(*child)] = *parent;
};

template <class Type>
void BinaryTree<Type>::setLeft(Type& val) {

    // set a given value in the child array to indicate a left child
   childArray[val] = 0;
};

template <class Type>
void BinaryTree<Type>::setRight(Type& val) {

    // set a given value in the child array to indicate a right child
    childArray[val] = 1;
};

template <class Type>
int BinaryTree<Type>::getRoot() {

    // find the root value of the tree
    for (int i = 0; i < size(); i++) {
        if (parentArray[i] == -1) {

            // and return it
            return i;
        };
    };
};

int  main() {
    int* val1 = new int;
    int* val2 = new int;
    int* val3 = new int;
    int count;

    cin >> count;

    BinaryTree<int> bt(count);

    for (int i = 0; i < count; i++) {
        cin >> *val1;
        cin >> *val2;
        cin >> *val3;

        if (i == 0) {
            bt.setRoot(*val1);
        };

        if (*val2 != -1) {
            bt.setParent(val2, val1);
            bt.setLeft(*val2);
        }
        if (*val3 != -1) {
            bt.setParent(val3, val1);
            bt.setRight(*val3);
        }

        val1 = new int;
        val2 = new int;
        val3 = new int;
    };

    cout << bt.size() << endl;
    bt.postorder(bt.getRoot());
    cout << endl;
    bt.preorder(bt.getRoot());
    cout << endl;

    delete val1;
    delete val2;
    delete val3;
};

BinaryTree 类中的一些函数还没有完成，只是在其中包含填充垃圾用于测试。

Answer 1

您的 BinaryTree 析构函数始终确保：

delete[] parentArray;
delete[] childArray;

不幸的是，该类的构造函数之一没有new 任何这些数组。因此，析构函数最终会尝试delete 一对未初始化的垃圾指针。

这个类violates the Rule Of The Three也有可能，但是我没有充分分析这个。

编辑：正如在 cmets 中指出的那样，这些不是指针；所以无论如何这是错误的，但出于其他原因。