调试断言失败！表达式：is_block_type_valid(标头>_block_use)。对象不会初始化和推送错误

首先，让我感谢您为我查看这段代码，因为它已经困扰我一段时间了，我似乎找不到问题。

当我运行它时，它不会在控制台中抛出任何错误，而是抛出以下错误:

调试断言失败!

程序:[Filepath to .exe]文件:minkernel crt ucrt src appcrt debug_heap.cpp堆第892行

表达式:is_block_type_valid(头-> _block_use)

我一直想弄清楚，但就是不适合我。我相信这与我传递的模板类型有关，因为只有当我尝试初始化minHeap对象或尝试我的Push方法时，它才会崩溃，我也认为这是一个问题。

再次感谢大家看我的代码。

#include "minHeap.h"
#include "Node.h"
#include <iostream>
using namespace std;
int main() {
    Node<char> A = Node<char>(0, 'A');
    Node<char> B = Node<char>(1, 'B');
    Node<char> C = Node<char>(2, 'C');
    Node<char> D = Node<char>(3, 'D');
    minHeap<char> myHeap = minHeap<char>();
    //Below doesn't work, something about subscript is not of integrap type
    //myHeap.push(A.index, A.value);
    //myHeap.push(B.index, B.value);
    //myHeap.push(C.index, C.value);
    //myHeap.push(D.index, D.value);
    cout << A.index << endl;
    myHeap.~minHeap();
    return 0;
}

Node.h:

#pragma once
template<typename T>
class Node
{
public:
    float index;
    T value;
    Node(float indx, T val);
    ~Node();
};
template<typename T>
inline Node<T>::Node(float indx, T val)
{
    index = indx;
    value = val;
}
template<typename T>
inline Node<T>::~Node()
{
}

最后，minHeap:

#pragma once
template<typename T>
class minHeap
{
private:
    T* arr[100];
    int arrSize = 0;
    void heapifyUp(int indx);
    void heapifyDown(int indx);
    int getParent(int indx);
    int childLeft(int indx);
    int childRight(int indx);
    int swap(int indxA, int indxB);
public:
    minHeap();
    ~minHeap();
    void push(int indx, T val);
    void pop();
};
template<typename T>
inline minHeap<T>::minHeap()
{
}
template<typename T>
inline minHeap<T>::~minHeap()
{
    delete[] arr;
}
template<typename T>
inline void minHeap<T>::heapifyUp(int indx)
{
    if (indx <= 0) return;
    int j = getParent(indx);
    if (arr[indx] < arr[j]) {
        int temp = arr[indx];
        arr[indx] = arr[j];
        arr[j] = temp;
    }
    heapifyUp(j);
}
template<typename T>
inline void minHeap<T>::heapifyDown(int indx)
{
    int j;
    //if no left child
    if (childLeft(indx) > arrSize - 1) return;
    //if no right child
    if (childRight(indx) > arrSize - 1) j = childLeft(indx);
    //No children
    else j = (arr[childLeft(indx)] < arr[childRight(indx)]) ? (childLeft(indx)):(childRight(indx));
    if (arr[indx] > arr[indx]) {
        int temp = arr[indx];
        arr[indx] = arr[j];
        arr[j] = temp;
    }
    heapifyDown(j);
}
template<typename T>
inline int minHeap<T>::getParent(int indx)
{
    return (indx - 1) / 2;
}
template<typename T>
inline int minHeap<T>::childLeft(int indx)
{
    return 2 * i + 1;
}
template<typename T>
inline int minHeap<T>::childRight(int indx)
{
    return 2 * i + 2;
}
template<typename T>
inline int minHeap<T>::swap(int indxA, int indxB)
{
    int tempA = arr[indxA];
    int tempB = arr[indxB];
    arr[indxA] = tempB;
    arr[indxB] = tempA;
    return 0;
}
template<typename T>
inline void minHeap<T>::push(int indx, T val)
{
    //Something with Array is broken. Fix it pupper
    int tempVal = arr[indx];
    arr[indx] = val;
    arrSize += 1;
    heapifyUp(arrSize - 1);
}
template<typename T>
inline void minHeap<T>::pop()
{
    int temp = arr[0];
    arr[0] = arr[arrSize - 1];
    arr[arrSize - 1] = nullptr;
    arrSize -= 1;
    heapifyDown(0);
}