Debug Assertion Failed! Expression: is_block_type_valid(header->_block_use). Object wont init and Push error

Question

In advanced, let me thank your for looking at this code for me, because it has been bugging me for a while now and I can't seem to find the issue.

Whenever I run it, it doesn't throw any errors within the console, instead it throws this error:

Debug Assertion Failed!

Program: [Filepath to .exe] File: minkernel\\crts\\ucrt\\src\\appcrt\\heap\\debug_heap.cpp Line 892

Expression: is_block_type_valid(header->_block_use)

I've been trying to figure it out, but it just wont work for me. I believe it has something to do with the template types I am passing in, as it only crashes whenever I try to initialize a minHeap object or try my Push method, which I also believe is an issue.

Once again, thank you all so much for looking at my code.

Main:

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

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

And finally, 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

Why are you calling myHeap.~minHeap(); ? This results in myHeap being destroyed twice, with the second call trying to free memory that has already been freed. This can cause the error you're seeing.

You can construct your variables a lot more concisely:

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