Programmeren in C++: snelcursus

	enkelvoudige variabele	tabelvariabele	pointervariabele
const	int x;	const int * tab; const int tab [];	int * p;
uitvoer	int & x;	int * tab; int tab [];	int * & p;

Voor variabelen (objecten) van een zelfgemaakte klasse, geldt hetzelfde. Alleen geven we hier nooit een copie door, gezien een object zeer groot kan zijn.

	enkelvoudige variabele	tabelvariabele	pointervariabele
const	const ding & z;	const ding * tab; const ding tab [];	ding * zp;
uitvoer	ding & z;	ding * tab; ding tab [];	ding * & zp;

Bij oproep van een functie met bovenstaande parameters, moet je niet beginnen twijfelen over de variabele die je meegeeft aan de functieoproep. Zorg ervoor dat de variabele hetzelfde type heeft als de parameter. Dus toegepast op de functies van bovenstaande tabel (voor basistype uitgeschreven; voor zowel constante als uitvoerparameter):

	enkelvoudige variabele	tabelvariabele	pointervariabele
	int t; int * tp = new int; functie(t); functie(*tp);	int t[20]; int * tp = new int[20]; functie(t); functie(tp);	int * xp; functie(xp);

Oefeningen op gebruik van pointers

1. Beschouw volgende variabelen en hun type :

   int i, *ip;
   double d, *dp;
   

   Welke van volgende beweringen zijn (syntactisch) correct? Indien ze correct zijn, verklaar wat ze uitdrukken. Indien je niet zeker bent, probeer dan de code uit in een programma.

   i=7;	ip=&7;	&i=ip;
   &i=*7;	ip=&i;	*ip=i;
   *ip++;	(*ip)++;	*ip *= i;
   *ip = *&i;	ip++;	i = ip - &i;
   dp = &i;	dp = ip;	&dp = &&d;

2. Gegeven: zes korte programma's, waarvan hooguit enkele juist zijn. Geef aan welke niet, en waarom. Als je dit foutloos doet, heb je de basiswerking van pointers door. Gebruik enkel pen en papier!
   Hint: deel je blad op in twee kolommen, waarbij links de (gewone en pointer-)variabelen komen die in het hoofdprogramma gebruikt worden, en waarbij rechts de variabelen uit de functie/procedure getekend worden. Geef aan wat er gebeurt bij oproep van de module, en bij afsluiten van de module (i.e. welke (waarden van de) variabelen worden doorgegeven van hoofdprogramma naar module, en omgekeerd?) De lokale variabelen teken je in blauw, de dynamische variabelen in rood.
   Wat ontbreekt in programma 1, 5 en 6?

   VERSIE 1 double* kwadraat (double a){ double *q= new double; *q = a*a; return q; } int main(){ double* p; p=kwadraat(3.1); cout<<*p; }	VERSIE 4 void kwadrateer (double*& q, double a){ *q = a*a; } int main(){ double* p; kwadrateer(p,3.1); cout<<*p; }
   VERSIE 2 double* kwadraat (double a){ double q; q = a*a; return &q; } int main(){ double *p; p=kwadraat(3.1); cout<<*p; }	VERSIE 5 void kwadrateer (double* q, double a){ q=new double; *q = a*a; } int main(){ double* p; kwadrateer(p,3.1); cout<<*p; }
   VERSIE 3 void kwadrateer (double* q, double a){ *q = a*a; } int main(){ double* p; kwadrateer(p,3.1); cout<<*p; }	VERSIE 6 void kwadrateer (double*& q, double a){ q=new double; *q = a*a; } int main(){ double* p; kwadrateer(p,3.1); cout<<*p; }

3. Schrijf een functie c_str(str) die een string str omzet in een C-string. In de programmeertaal C wordt een string voorgesteld als een pointer naar een tabel van karakters afgesloten met 0. De functie c_str geeft bijgevolg een pointer terug!
   
   Schrijf een bijhorend hoofdprogramma om deze functie uit te testen.

4. Gegeven volgende code.

   #include <iostream>
   #include <fstream>
   #include <string>
   using namespace std;
   
   const int MAX = 25;
   
   void lees_bestand(string bestandsnaam, string items[],int &aantal)
   {
        aantal = 0;
        ifstream invoer(bestandsnaam.c_str());
        if (invoer.is_open())
        {
             string lijn;
             getline(invoer, lijn);
             while (!invoer.fail() && aantal<MAX)
             {
                  if (lijn.size() > 0)
                  {
                       items[aantal] = lijn;
                       aantal++;
                  }
                  getline(invoer, lijn);
             }
             if (! invoer.eof())
                 cout<<bestandsnaam<<" bevat fouten of is niet volledig ingelezen "<<endl;
        }
        invoer.close();
   }
   
   void schrijf(const string items[],int n){
       for(int i=0;i<n;i++)
           cout<<items[i]<<endl;
   }
   
   int main()
   {
       string namen[MAX];
       int aantal;
       lees_bestand("namen.txt", namen, aantal);
       schrijf(namen,aantal);
       return 0;
   }
   

   
   Verwijder hierin de constante MAX, en pas de code aan zodat de tabel dynamisch wordt aangemaakt in de module en nooit groter is dan noodzakelijk.
   Vervang in de hoofding van elke module string items[] door string *items, en doe de nodige aanpassingen zodat het programma terug werkt.

Gevolgen voor constructor en destructor in C++

De destructor is de lidfunctie die een object netjes opruimt als de levensduur van het object afgelopen is. Deze wordt nooit expliciet aangeroepen, maar moet wel geïmplementeerd worden. Een destructor zal altijd, automatisch, zonder dat je code moet toevoegen, alle lidvelden terug vrijgeven aan het geheugen. Maar als één van die lidvelden een pointer is, zal ENKEL de pointer vernietigd worden, en NIET de variabele/het object waarnaar die pointer verwijst. Dat wil dus zeggen dat dat object voor altijd in het geheugen blijft zitten (er is nl. geen wegwijzer meer naartoe). Gevolg: memory leak.

Hoe kan je nagaan of je een memory leak hebt? Daarvoor schrijf je (in de testfase van je programma) in de destructor uit wAt je precies vernietigt.
(Let op: "delete k;" met k een nullpointer is mogelijk,
maar "cout<<"ik vernietig nu knoop met sleutel "<<k->sl<<endl;" met k een nullpointer werkt niet. (Maak eventueel onderscheid met if/else bij het uitschrijven.)
Tel bij het runnen van je programma na: heb je 15 knopen aangemaakt, dan moet je 15 keer de "delete"-melding krijgen op je scherm (al dan niet op het einde van je programma).

Hoe kan je een memory leak vermijden? Door consequent "delete" te gebruiken waar nodig (in de destructor dus).

Hoofdstuk 3: gelinkte lijsten

Gelinkte lijst: niet-recursieve basisversie

typedef int T;   // type van een sleutel; te vervangen indien nodig
class Lijstknoop;
class Lijst{
    public:
        Lijst();       // constructor: maak een nieuwe lijst aan
        ~Lijst();      // destructor: geef alles wat je met new aanmaakte,
                       // hier weer vrij aan het geheugen.
     
        int geefaantal() const;   
        void voegtoe (const T &);
        void verwijder (const T &);
        
        friend ostream& operator<< (ostream& os, const Lijst& l){
            l.schrijf(os);
            return os;   
        }
        
    protected:
        Lijstknoop * eerste;        
        void schrijf(ostream & os) const;
};

class Lijstknoop{
    friend class Lijst;
    private:
        T sl;
        Lijstknoop* volgende;
        Lijstknoop();
        ~Lijstknoop();
        Lijstknoop(const T&);  
};         

Gelinkte lijst: recursieve basisversie

typedef int T;   // type van een sleutel; te vervangen indien nodig

class Lijstknoop;
class Lijst{
    public:
        Lijst();       // constructor: maak een nieuwe lijst aan
        ~Lijst();      // destructor: geef alles wat je met new aanmaakte,
                       // hier weer vrij aan het geheugen.
        
        int geefaantal()const;
        void voegtoe (const T &);
        void verwijder (const T &);
        
        friend ostream& operator<< (ostream& os, const Lijst& l){
            l.schrijf(os);
            return os;   
        }
        
    protected:
        Lijstknoop * k;    // naamwijziging...
        void schrijf(ostream & os) const;
};

class Lijstknoop{
    friend class Lijst;
    private:
        T sl;
        Lijst volgende;    // enige punt waarop interface 
                           // recursief/niet-recursief verschilt
        Lijstknoop();
        ~Lijstknoop();
        Lijstknoop(const T&);  
};  

Gelinkte lijst: niet-recursieve uitgebreide versie

Gelinkte lijst: recursieve uitgebreide versie

Dubbelgelinkte lijst

Let op:

1. De code van de gelinkte lijsten die je hier maakt moet foutloos zijn! Deze klasse vormt immers de basis voor de labo's algoritmen - en elke fout in je code zal je dus blijven achtervolgen. Je moet de code die je schrijft dus TESTEN. Dat geldt voor alle code die je schrijft. Je moet er altijd over nadenken hoe je dat doet. Probeer zo veel mogelijk omstandigheden te bedenken. In het geval van een lijst: probeer dingen toe te voegen. Probeer dingen te verwijderen die er zijn, die herhaalde malen voorkomen. Probeer dingen te verwijderen uit een lege lijst. Vul een lijst op, haal hem leeg, vul hem terug op, enzovoorts. Alleen zo vind je de fouten, en alleen als je de fouten vindt wordt je code bruikbaar.
2. Houd voor jezelf de tijd bij die je met pen en papier spendeert aan de vraag, versus de tijd die je doorbrengt aan je klavier. We schatten een normale verhouding op 2:1 (met 2 wel degelijk in het voordeel van pen en papier).
3. Hoeveel schetsjes van lijsten en/of knopen heb je gemaakt bij het ontwerpen van je code?

Sneeuwbaleffect bij destructor

class Lijst{
    protected:	
        Lijstknoop* k;
};

class Lijstknoop{
    protected:
        int sl;
        Lijst volgend; 		
};

Stel dat je ergens in je code, voor een bepaalde Lijstknoop* k, "delete k" schrijft. Wat gebeurt er dan? Het object waar k naar wijst (een Lijstknoop dus) wordt weer vrijgegeven aan het geheugen. Dus wordt de destructor opgeroepen voor die Lijstknoop met naam *k. Voor het datalid sl van *k betekent dit niets speciaals (geheugenplaats voor een int wordt gewoon vrijgegeven). Het datalid volgend van *k is echter een Lijst, dus wordt de destructor van de klasse Lijst opgeroepen. Dit impliceert: delete l (met l=k->volgend.k), dus wordt ook de volgende knoop in het lijstje vrijgegeven aan het geheugen. Vandaar: het sneeuwbaleffect bij de destructor. Opgelet, dit heeft soms ongewenste effecten. Kijk vooral na of het verwijderen van een knoop uit een lijst netjes gebeurt (delete niet vergeten, maar ook niet teveel verwijderen.)