Debug Assertion Failed ! Expression : is_block_type_valid(header->_block_use). L'objet ne s'initie pas et l'erreur Push

Question

Je vous remercie d'avance d'avoir examiné ce code pour moi, car il me dérange depuis un certain temps déjà et je n'arrive pas à trouver le problème.

Chaque fois que je l'exécute, il n'affiche pas d'erreur dans la console, mais cette erreur :

L'assertion de débogage a échoué !

Programme : [Filepath to .exe] Fichier : minkernel \crts\ucrt\src\appcrt\heap\debug_heap.cpp Ligne 892

Expression : is_block_type_valid(header->_block_use)

J'ai essayé de le comprendre, mais ça ne marche pas pour moi. Je pense que cela a quelque chose à voir avec les types de modèles que je passe, car il ne se bloque que lorsque j'essaie d'initialiser un objet minHeap ou d'essayer ma méthode Push, ce qui, je pense aussi, est un problème.

Encore une fois, merci beaucoup à tous d'avoir regardé mon code.

Principal :

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

Voici 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()
{
}

Et enfin, 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);
}

Answer 1

Pourquoi appelez-vous myHeap.~minHeap(); ? Il en résulte que myHeap étant détruit deux fois, le deuxième appel essayant de libérer de la mémoire qui a déjà été libérée. Cela peut provoquer l'erreur que vous voyez.

Vous pouvez construire vos variables de manière beaucoup plus concise :

Node<char> A(0, 'A');
minHeap<char> myHeap;