C/C++ - traccia esame

Buongiorno a tutti. Sono uno studente di Ing. dell'Informazione e tra 3 settimane circa ho l'esame di Fondamenti. Sto sbattendo da un pò di giorni su questa traccia d'esame:
1- Esercizio in C che ho posta qui-> pierotofy.it/pages/extras/forum/…=

2- Scrivere il codice C++ per la realizzazione dei una classe che implementa un heap di massimo 127 elementi float. Prevedere costruttore che crea heap vuoto, costruttore che riceve array di float e numero di float e crea l'heap con gli stessi elementi dell'array, funzione di inserimento ed estrazione, distruttore, costruttore di copia ed eventuali funzioni necessarie al funzionamento.

Questa è una mia bozza:

#include <iostream>
using namespace std;

class heap {
   int num_el, j;
   float *p_el, new_el;
   public:
      heap() {cout<<"Costruttore\n"; num_el=0; p_el=NULL; }
      ~heap() {cout<<"Distruttore\n"; if(num_el>0 && num_el<=127) delete []p_el; }
      heap(const heap &s);
      void heapify(int i, int l, int r);
      heap(int n, float p) : num_el(n), p_el(p) {
         for(j=0; j<num_el; j++) {
            p_el[++num_el] = new_el;
            heapify(num_el, 1, num_el);
         }
      }
};

void heap::heapify (int i, int l, int r) {
   int child;
   float *temp;
   temp=p_el[i];
   while (i>=l && temp<p_el[i/2]) {
      p_el[i]=p_el[i/2];
      i/=2;
   }
   p_el[i]=temp;
   while (i<=r/2) {
      child=2*i;
      if (child+1<=r && p_el[child+1]<p_el[child])
         child++;
      if (temp<=p_el[child]) break;
      p_el[i]=p_el[child];
      i=child;
      }
   p_el[i]=temp;
}

heap::heap(const heap &s) 
{
	try{
		p_el=new int[s.num_el];
	}
	catch(bad_alloc xa){
		cout<<"Errore allocazione in costruttore copie!\n";
		num_el=0;
		return;
	}
	num_el=s.num_el;
	for(int i=0;i<num_el;i++)p_el[i]=s.p_el[i];
}


int main()
{
   int num, i;
   float *ptr;
   
   cout<<"num. el:";
   cin>>num;
   if(num>0 && num<=127) {
      ptr = new float[num];
      cout<<endl;
      for(i=0; i<num; i++) {
         cout<<"ins. el:";
         cin>>ptr[i];
         cout<<endl;
      }
   heap H(num, ptr);
   
   system("pause");
   return 0;
}

L'ho scritta inserendo materiale reperito qua e la, ma i concetti non mi sono chiari, mi servirebbe una spiegazione coscienziosa vista l'imminenza dell'esame.
Vi ringrazio di cuore e vi auguro buone feste

Uno heap si comporta esattamente come un binary tree, con la differenza che è più flessibile (il binary tree impone che il nodo child a sinistra sia più piccolo del nodo parent e quello di destra più grande, mentre uno heap impone semplicemente che entrambi i nodi child siano più piccoli - o più grandi dipendentemente dal fatto che tu stia implementando un max heap o un min heap - del nodo parent).

en.wikipedia.org/wiki/…

Il codice è piuttosto ingarbugliato... vi hanno spiegato il concetto di usare identificatori descrittivi e l'importanza dei commenti?

Ho modificato il codice, ed ora va tutto bene. Solo non ho capito il funzionamento del costruttore di copia...

#include <iostream>
#define MAX 127
using namespace std;

class heap {
   int num_el, j;
   float *p_el;
   public:
      int ArraySize, HeapSize;
      heap() {cout<<"Costruttore\n"; num_el=0; p_el=NULL; }
      ~heap() {cout<<"Distruttore\n"; if(num_el>0 && num_el<=127) delete []p_el; }
      heap(const heap &s);
      void BuildHeap(float A[MAX]);
      void HeapSort(float A[MAX]);
      void heapify(float A[MAX], int i);
      int left(int i) { return 2*i+1;}
      int right(int i) { return 2*i+2;}
      int parent (int i) {return (i-1)/2;}
      void swap(float A[MAX], int i, int j);
};

void heap::swap(float A[MAX], int i, int j) {
   float tmp = A[i];
   A[i] = A[j];
   A[j] =tmp;
}

void heap::HeapSort(float A[MAX])
{
   int i;
   BuildHeap(A);
   for (i=ArraySize-1; i>=1; i--) {
      swap(A, 0, i);
      HeapSize--;
      heapify(A, 0);
   }
}

void heap::BuildHeap(float A[MAX])
{
   int i;
   HeapSize = ArraySize;
   for (i=ArraySize/2; i>=0; i--)
      heapify(A, i);
}

void heap::heapify(float A[MAX], int i)
{
   int l,r,largest;
   l = left(i);
   r = right(i);
   if (l < HeapSize && A[l] > A[i])
      largest = l;
   else largest = i;
   if (r < HeapSize && A[r] > A[largest])
      largest = r;
   if (largest != i) {
      swap(A, i, largest);
      heapify(A, largest);
   }
}

heap::heap(const heap &s) 
{
	try{
		p_el=new float[s.num_el];
	}
	catch(bad_alloc xa){
		cout<<"Errore allocazione in costruttore copie!\n";
		num_el=0;
		return;
	}
	num_el=s.num_el;
	for(int i=0;i<num_el;i++)p_el[i]=s.p_el[i];
}


int main()
{
   int num, i, k;
   float ptr[MAX];
   heap Heap; //istanzio un oggetto della classe astratta heap
   
   cout<<"num. el:";
   cin>>num;
   if(num>0 && num<=127) {
      cout<<endl;
      for(i=0; i<num; i++) {
         cout<<"ins. el:";
         cin>>ptr[i];
         cout<<endl;
      }
   }
   Heap.HeapSize=Heap.ArraySize=num;
   Heap.HeapSort(ptr);
   for (k=0;k<num;k++)
      cout<<ptr[k]<<" ";
   cout<<endl;
   
   system("pause");
   return 0;
}

il costruttore copia è il costruttore che viene chiamato quando si crea una nuova istanza copiando da un'altra istanza. In questo caso bisogna copiare i buffer interni di memoria dinamica in modo da non incorrere in problemi dopo la deallocazione del primo oggetto.