/* feedback bij reeks 4
 * PROBLEEM :        heap
 * INHOUD FEEDBACK : zeven korte opmerkingen bij gevonden code
 * TE DOEN :         nagaan of je de commentaar verstaat
 *                   en bruikbaar vindt
 */

OPM 1 

Gelezen in Heap::~Heap:
	
	delete data;
	
Verbeterd: 

    data ++ ;         // in constructor stond data --;
    delete [] data;   // omdat data pointer naar TABEL is ipv enkelvoudige var
    
OPM 2

Gelezen in Heap::pop:
	
	T last = data[size];
	data[size] = INT32_MIN;    
	
Verbeterd:
	
	Het element dat laatst in de tabel staat valt nu net buiten de heap
	(een copie zal op de juiste plaats in de heap terechtkomen).
	Gezien je NIET WEET waar het type T voor staat, kan je geen vervanging
	opperen voor dat laatste element. (Als 'T' staat voor 'Zangvogel',
	wat is de Zangvogel met waarde INT32_MIN dan?)	
	Laat dit element gewoon ongewijzigd; de heap kent z'n size,
	dus zal dit element niet meer raadplegen (enkel overschrijven bij push)

OPM 3

Gelezen in Heap::pop:
	
	int new_pos = 1;
    int child1 = 2*new_pos, child2 = 2*new_pos + 1;

    while((last < data[child1] && child1 <= size) ||
            (last < data[child2] && child2 <= size)){
        // grootste van de twee kinderen selecteren en in parent plaatsen   
        if(child1 <= size && child2 <= size){
            data[new_pos]=
                    (data[child1] < data[child2])? data[child2]:data[child1];
        }
        else if(child1 <= size){
            data[new_pos] = data[child1];
        }
        else{
            data[new_pos] = data[child2];
        }
        /* nieuwe uitgangspositie bepalen en
         * nieuwe kindindexen bepalen */
        new_pos=(data[child1] < data[child2])? child2:child1;
        child1 = 2*new_pos, child2 = 2*new_pos + 1;
    }

    data[new_pos] = last;
	
Commentaar:
	
	Het bepalen van het grootste kind komt tweemaal voor:
	een keertje bij het klaarzetten voor de nieuwe doorloop van de lus,
	en een keertje bij toewijzing van data[new_pos].
	Als een berekening tweemaal voorkomt, bewaar je het resultaat beter
	in een variabele. bvb. grootste_kind.
	Dus: 
	    grootste_kind = 2*new_pos;
	    if(grootste_kind+1 <= size && data[grootste_kind]<data[grootste_kind+1])
	        grootste_kind ++;
	
	
	
	De code 
	    "last < data[child1] && child1 <= size"
	zal meestal probleemloos lopen, tenzij size=capacity en child1=size+1.
	VOOR je binnen de []-haakjes een index plaatst, moet je zeker
	zijn dat die index geldig is. Dus gebruik lazy evaluation zoals het hoort:
	zet eerst "child1 <= size" en dan "last < data[child1]"
	
	
OPM 4
	
Gevraagd geweest:
	
	Hoe komt het dat de unittest soms 1, soms 3 fouten oplevert?
	Hoe vind ik die fouten dan?
	
Antwoord:
	
	Raadpleeg de code van de unittest. Daar wordt blijkbaar 
	(naast hardgecodeerde data) ook een random test-vector aangemaakt. 
	Met wat geluk passeer je die test, anders niet.
	(Met andere woorden: de unittest is niet waterdicht. Zullen we beter doen
	in het vervolg...)
	
	Vind je de oorzaak van de fout niet, laat de unittest dan uitschrijven
	welke randomwaarden hij gebruikt. Laat een aantal keer lopen, tot de fouten
	opduiken, en ga met deze uitgeschreven randomwaarden aan de slag 
	(codeer ze hard). 
	
	ZOEKSTRATEGIE NAAR FOUTEN:
		Zorg eerst dat je fouten reproduceerbaar zijn;
		dus GEEN randomwaarden gebruiken.
		Met die gegevens debuggen of tussentijdse gegevens uitschrijven.
		Of tussentijdse output vergelijken met de output die code van je buur 
		oplevert (op voorwaarde dat die code de unittest wel passeerde).
		In dit geval: controleer of jouw heap dezelfde opbouw heeft als
		de heap van je buur.	
	
OPM 5

Gelezen:
	
	while(data[parent] < x){
		...
		parent /= 2;	
	}	
	
Verbeterd:
	
	Bij ELKE index zorg je dat de grenzen niet overschreden worden - ook niet
	vooraan de tabel of vector.
	(Wil je dit oplossen met een dummy 'grootste' element te plaatsen in data[0]?
	Dan zit je weer met het probleem dat je type T niet goed genoeg kent!)
	
	
OPM 6

Gestelde vraag:
	
	Bij het uitvoeren van de unittest crasht het programma zodra deze 
	aan de lijn: '_check_no_throw()' komt.

Raad:
	Ga na of je overal exceptions opwierp waar gevraagd.
	Try-catch-blokken zal je (nog) niet nodig hebben in je klasse;
	het is maar op het ogenblik dat je bvb. 'pop' oproept,
	dat je deze oproep in een try-blok moet omvatten.
	
OPM 7	
	
Gelezen code:	
	
	void verdubbel_capaciteit(){
        T* oud = data;
        data = new T[capaciteit*2];  
        //kopieer gegevens
        for(int i=1; i<=capaciteit; i++)
            data[i] = oud[i];
        capaciteit *= 2;
    }
		
Commentaar:
	
	Het idee op zich is prima; zo vermijd je overflow. 
	Let echter op: als dit niet in de interface werd aangegeven, zal de unittest
	(die ongetwijfeld probeert de capaciteit te overschrijden) tevergeefs
	wachten op het opwerpen van de exceptie 'capacity exceeded'.
	En krijg je foutmeldingen.
	
Verbetering van code:
	
	Omdat data net VOOR het begin van de tabel verwijst (zie constructor:
	truukje om telwerk in heap te vereenvoudigen), moet	je hier zeer 
	voorzichtig zijn!!	Concreet:
		
		'data++;' toevoegen voor eerste regel
	    for-lus van 0 tot (net voor) 'ingebruik' (rest hoef je niet te copieren)
        op het einde nog:
		'data--;' toevoegen
		'delete [] oud;' toevoegen