Strange Segmentation Fault in Heap Implementation - c++

Question

Given below is a driver program I have written for using my own implementation of a heap.
#include<iostream>
#include"Heap.h"
int main(){
Heap h(30);
h.insert(1);
h.insert(3);
h.insert(5);
h.insert(6);
h.insert(5);
h.insert(8);
h.display();
std::cout<<h.extractMin(); // Statement 1
h.display();
}
This gives the desired result as:
========= Heap Contents =========
1 3 5 6 5 8
1
========= Heap Contents =========
3 6 5 8 5
However, if I change the statement 1 to:
std::cout<<"Min: "<<h.extractMin();
the code starts giving a Segmentation fault. Again, if I change the statement 1 to
int z = h.extractMin();
the code still gives a Segmentation fault. This tempted me to see if I am doing something wrong in extractMin(). Below is my definition of extractMin():
int Heap::extractMin()
{
int min = this -> arr[0];
this -> arr[0] = this -> arr[heapSize];
heapSize -= 1;
heapify(0);
return min;
}
And just for completeness's sake below is my definition for heapify():
void Heap::heapify(int index){
if(index > this -> heapSize)
return;
int smallest = index;
int l = leftChild(index);
int r = rightChild(index);
if(l <= heapSize && arr[l] < arr[index])
smallest = l;
if(r <= heapSize && arr[r] < smallest)
smallest = r;
if(smallest != index){
arr[smallest] = arr[smallest] ^ arr[index];
arr[index] = arr[smallest] ^ arr[index];
arr[smallest] = arr[smallest] ^ arr[index];
heapify(smallest);
}
}
Any idea what's going on? I am unable to understand the reason behind segmentation fault. Is there anything obvious I am missing?
Thank you!
Addition 1:
This happens for h.getHeapSize() and h.getArrSize() as well, which makes me think that the problem lies in something else and not in the functions.
Addition 2:
The entire code goes below:
#include<iostream>
#include<cmath>
class Heap{
private:
int* arr;
int size;
int heapSize;
public:
Heap(int = 8);
Heap(int*, int size);
int* initArr(int size);
void setSize(int);
int getSize();
int getHeapSize();
void setHeapSize(int);
int leftChild(int);
int rightChild(int);
int parent(int);
void heapify(int);
void buildHeap();
void insert(int);
int extractMin();
void display() const;
};
Heap::Heap(int size){
initArr(size);
this -> size = size;
this -> heapSize = -1;
}
Heap::Heap(int* arr, int size){
this -> arr = arr;
this -> size = size;
this -> heapSize = size - 1;
buildHeap();
}
int* Heap::initArr(int size){
int* arr = new int[size];
return arr;
}
void Heap::setSize(int size){
if(size > this -> heapSize)
this -> size = size;
}
int Heap::getSize(){
return this -> size;
}
void Heap::setHeapSize(int heapSize){
this -> heapSize = heapSize;
}
int Heap::getHeapSize(){
return this -> heapSize;
}
int Heap::leftChild(int index){
return 2*index + 1;
}
int Heap::rightChild(int index){
return 2*index + 2;
}
int Heap::parent(int index){
return ceil(index >> 1) - 1;
}
void Heap::heapify(int index){
if(index > this -> heapSize)
return;
int smallest = index;
int l = leftChild(index);
int r = rightChild(index);
if(l <= heapSize && arr[l] < arr[index])
smallest = l;
if(r <= heapSize && arr[r] < smallest)
smallest = r;
if(smallest != index){
arr[smallest] = arr[smallest] ^ arr[index];
arr[index] = arr[smallest] ^ arr[index];
arr[smallest] = arr[smallest] ^ arr[index];
heapify(smallest);
}
}
void Heap::buildHeap(){
for(int i = heapSize/2 - 1; i >= 0; i-- )
heapify(i);
}
void Heap::insert(int val){
heapSize += 1;
int loc = heapSize;
arr[heapSize] = val;
int p;
while((p = arr[parent(heapSize)]) > val){
arr[loc] = arr[p] ^ arr[loc];
arr[p] = arr[p] ^ arr[loc];
arr[loc] = arr[p] ^ arr[loc];
}
}
int Heap::extractMin(){
//int temp = arr[0];
//arr[0] = arr[heapSize];
//arr[heapSize] = temp;
int min = arr[0];
arr[0] = arr[heapSize];
heapSize -= 1;
heapify(0);
//return arr[heapSize + 1];
return min;
}
void Heap::display() const{
std::cout<<"\n========= Heap Contents =========\n";
for(int i = 0; i <= heapSize; i++)
std::cout<<arr[i]<<'\t';
std::cout<<'\n';
}

Answer 1

There are numerous problems.
First, your constructor that takes an int parameter doesn't initialize the arr member, it allocates memory and assigns it to a local pointer variable, which it returns but you just ignore the return value.
You have to store it in the member variable (it's usually a very bad idea to name local variables the same as members.)
Once you fix that: during the first insertion, h.insert(1);, parent(heapSize) is -1.
Since you use that to index in the array, the program has undefined behaviour and all bets are off; the program isn't a valid C++ program.
There might be other problems as well, but those are the most obvious.

Answer 2

From what you posted here, improper handling of the heap size is to blame. All test involving heapSize do not seem to account for zero based accessing. You should really change this, as it leads to a lot of unlogical consequences: Does heapSize get initialized to -1?
As for debugging:
Leisurely add more null and boundary checks (not only to heapSize but also to 0)
Try reducing the test set (does it crash with one item?) and try to trace the control flow by hand or by using gdb
EDIT
The bug is in parent(). Try the debugging tips.