Writing heapify function from scratch, getting a “stack-based buffer overrun”

Question

I am trying to implement the heap sort algorithm for the first time, but I am getting an error with the heapify function.

Unhandled exception at 0x0005369A in heapify.exe: Stack cookie instrumentation code detected a stack-based buffer overrun.

The console does open, and the output is 999 10 5 11 1012398875 2 0 1 .

Could someone help me understand what is going wrong here? Thank you.

#include <iostream>

// given the address of element 0 of an array, and a non-zero index k, heapify assumes that the L/R subtrees
// of node k are max heaps. But the subtrees combined with node k do not necesarily form 
// a max heap. heapify interchanges the value at node k with the value of one of its children,
// and then calls itself on the subtree in question 
int heapify(int* n, int k, int sizeOfHeap)
{
    // terminate the function if the input "node" is not actually a node
    if (k > sizeOfHeap)
    {
        return 0;
    }
        int root = *(n + k); // value of kth node
        int leftChild = *(n + 2 * k); // value of left chold
        int rightChild = *(n + 2 * k + 1); // value of right child
        if (root < leftChild)
        {
            // swap value of kth node with value of its left child
            int temp = root;
            *(n + k) = leftChild;
            *(n + 2 * k) = root;

            // call heapify on the left child
            heapify(n, 2 * k, sizeOfHeap);
        }
        else
        {
            // swap value of kth node with value of its right child
            int temp = root;
            *(n + k) = rightChild;
            *(n + 2 * k + 1) = root;

            // call heapify on right child
            heapify(n, 2 * k + 1, sizeOfHeap);
        }
    
}

int main()
{
    // arr is the array we will heapify. 999 is just a placeholder. 
    // The actual (almost) heap occupies indices 1 - 7
    int arr[8] = {999, 3, 10, 11, 5, 2, 0, 1};
    int sizeOfHeap = 8;
    
    heapify(arr, 1, sizeOfHeap);

    // print out arr
    int i;
    for (i = 0; i <= 7; i++)
    {
        std::cout << arr[i] << std::endl;
    }
}
 

Answer 1

Unhandled exception at 0x0005369A in heapify.exe: Stack cookie instrumentation code detected a stack-based buffer overrun.

The console does open, and the output is 999 10 5 11 1012398875 2 0 1.

Could someone help me understand what is going wrong here? Thank you.

Stack of process (one of real-live uses of stack data structure, FILO queue ) is the place in memory for static allocation. Always small and mostly same size for all processes. On stack, still, compiler save local variables ie small statically allocated buffers (this happens then the stack pointer is, on Linux, moved to expand the stack size, and compiler evaluate offsets on stack). They (buffers) could not be handled correctly (unsafe lib functions, like strcpy() ) so they could be potentially overflowed (overrunned) leading to buffer overflow vulnerability.

Stack cookie AKA stack canary is mitigation technique for writing sequential data on stack while attacker try to exploit vulnerability like stack buffer overflow , but not limited to (if You do stack pivot from heap back to heap but badly overwrite saved instruction pointer... nevermind ;) ). If the overflow is detected then they raise SegFault. Example link with example of exploitation.

This answers Your direct question (understand what is going wrong).

Now, You should debug it and then narrow down the issue. Especially ask the next question, not edit again.