Kennismaking met C++

Object georiënteerde talen hebben een aantal specifieke kenmerken die ze onderscheiden van niet object georiënteerde talen. Deze eigenschappen zijn:

De taal C++ is ontworpen door Bjarne Stroustrup en is volledig gebaseerd op C. C op zijn beurt is afgeleid van zijn voorganger BCPL. De commentaarstarter // die in C++ ingevoerd is, bestond al in BCPL. Heel wat concepten van C++ (de naam C++ werd in de zomer van 1983 uitgevonden) zijn afgeleid van andere programmeertalen. Het klasseconcept met afleidingen en virtuele functies werd van Simula67 overgenomen. De mogelijkheid om bewerkingstekens een andere betekenis te geven en om overal in het programma declaraties van variabelen te schrijven is van Algol68 overgenomen. Zo ook komen de ideeën voor templates en exceptions uit Ada, Clu en ML. C++ werd door de auteur ontworpen voor eigen gebruik. De eerste versie was geen eigen compiler maar wel een C naar C++ omzetter. Dit programma heette cfront. Door de stijgende populariteit van C++ bleek toch een standaardisatie noodzakelijk. Deze stap in gang gezet binnen ANSI als de X3J16 commissie in 1989. De ANSI C++ standaardisatie zal vermoedelijk ook deel uitmaken van een internationale ISO standaard. Tijdens de periode van het ontstaan tot de standaardisatie is C++ geëvolueerd. Een aantal wijzigingen zijn er gekomen na het opdoen van praktische ervaring.

Oorspronkelijk werd C ontworpen om assembler te vervangen. Ook C++ kan in deze optiek gebruikt verder gebruikt worden. Met andere woorden C++ staat dicht bij de machine. Van de andere kant is C++ bedoeld om de complexiteit van een probleem in kaart te brengen. Door een klassehierarchie op te bouwen is het mogelijk om een klare kijk te behouden op de gegevens en bijbehorende acties in een probleem. Hierdoor is het mogelijk dat één persoon met C++ programma's van meer dan 25.000 regels kan ontwerpen en onderhouden. In C zou dit veel moeilijker zijn.

Veel C programmeurs blijven liever bij C en zijn niet geneigd om C++ te leren. Hun argumenten zijn dikwijls als volgt:

Dit is een nieuw type in C++. Het referentietype maakt het mogelijk om een variabele te declareren die als synomiem van een andere variabele dienst doet.

int a;
int &x = a;
int &y; // Fout: initialisatie ontbreekt

x = 5;   // a is nu 5

De variabele is een gewoon geheel getal. De variabele x is een referentievariabele die verwijst naar de variabele a. Voor x is er geen opslagruimte voor een int. Als x gewijzigd wordt, wordt de inhoud van a gewijzigd. Een referentievariabele moet geinitialiseerd worden bij de declaratie. Daarom is de declaratie van y fout. Het is niet mogelijk om na de declaratie de referentievariabele naar een andere variabele te laten verwijzen.

De referentievariabele wordt dikwijls als formele parameter gebruikt. Hier is een klassiek voorbeeld:

void swap(int &x, int &y)
{
   int h;

   h = x;
   x = y;
   y = h;
}

void main()
{
   int a = 5;
   int b = 6;

   swap (a, b);   // verwissel a en b
}

Bij het gebruik als parameter gedraagt een referentietype zich als een VAR parameter in Pascal. Het voordeel is het feit dat in de functie swap de variabelen x en y er als een gewone variabele uitzien en niet als een pointervariabele.

C++ kent niet alleen het type struct maar ook het type class. Beiden kunnen gebruikt worden om gegevens in te kapselen. Dit doen we om gegevens, die sterk verbonden zijn, samen te brengen onder een noemer. Het sleutelwoord class is nieuw in C++ en laat de bescherming van de gegevens binnen een klasse toe.

Het eerste voorbeeld heeft wat te maken met grafische weergave van gegevens. In een grafische omgeving moeten we de coördinaten van een punt op het scherm bijhouden. Dit doen we door de coördinaten van een plaats op te slaan in een klasse:

class Punt
{
   int x;
   int y;
};

De klasse Punt bevat dus de velden x en y. Deze vorm van groeperen kennen we al van C. Met de klasse Punt kan een variabele gedeclareerd worden en we kunnen trachten om de velden x en y te bereiken.

        Punt p1;

De variabele p1 is van het type Punt en is in staat om 2 coördinaten te onthouden. Dit is niet meteen zichtbaar aan de variabele. Dit is het principe van de inkapseling. We gebruiken de term object om een variabele van een zekere klasse aan te duiden. Als we het in de toekomst over objecten hebben, dan bedoelen we hiermee variabelen of stukken dynamisch geheugen waarin zich informatie van een zekere klasse bevindt.

Als we de leden van het object p1 willen bereiken, dan zouden we het volgende kunnen uitproberen:

void main()
{
   Punt p1;

   p1.x = 50;
   p1.y = 70;
}

Helaas geeft dit programma twee compilatiefouten. De twee velden x en y zijn niet toegankelijk van buiten het object. Als we binnen de definitie van de klassen niet een van de woorden private, protected of public zijn alle leden privaat, private dus. We hadden evengoed dit kunnen schrijven:

class Punt
{
private:
   int x;
   int y;
};

Op deze wijze wordt duidelijk weergegeven dat de leden x en y niet publiek toegankelijk zijn.

Omdat de leden van de klasse Punt niet publiek toegankelijk zijn is er een probleem om bijvoorbeeld de variabele p1 te initialiseren of om de waarden x en y van een Punt object te weten te komen. Daarom zijn we verplicht tot de leden van een klasse via lidfuncties te organiseren. Een lidfunctie is een functie die deel uitmaakt van een klasse. Dikwijls wordt ook de term methode voor dit soort functies gebruikt. Er is een speciale vorm van een lidfunctie die enkel voor de initialisatie van een object wordt gebruikt. Deze vorm wordt constructor genoemd. Een constructor krijgt als naam de naam van de klasse.

class Punt
{
private:
   int x;
   int y;

public:
   Punt(int ix, int iy);
};

Binnen de klassebeschrijving noteren we een prototype van een functie. Omdat we voor de functienaam de naam van de klasse kiezen, is deze functie een constructor. We voorzien de constructor van twee formele parameters ix en iy. Dit betekent dat we aan de constructor twee getallen kunnen meegeven die dienen voor de initialisatie van het object. Bij een constructor mogen nooit een return type noteren; parameters mogen wel. In dit voorbeeld zijn er twee parameters.

Wat deze constructor moet doen, is nog niet vastgelegd. Binnen de klasse staat alleen maar een prototype. Nu zijn er twee manieren om de implementatie vast te leggen.

Punt::Punt(int ix, int iy)
{
   x = ix;
   y = iy;
}

Punt::Punt(int ix, int iy) : x(ix), y(iy)
{
}

class Punt
{
private:
   int x;
   int y;

public:
   Punt(int ix, int iy) : x(ix), y(iy)
   {
   }
};

Zoals we met een eenvoudig type een variabele kunnen declareren, kunnen we met een klasse een object declareren.

#include <iostream.h>

Punt pg(23, 34);

void main()
{
   Punt p1(30, 40);
   Punt p2 = Punt(44, 55);

   cout << "main\n";
}

Omdat er een constructor is die twee gehele getallen verwacht als parameter, moeten we bij de initialisatie tussen ronde haken twee getallen voorzien. Het is hier dat de constructor in actie treedt. Een constructor kunnen we nooit zelf starten. Een constructor wordt uitgevoerd voor een object, zodra dit object tot leven komt. Voor pg is dit zelfs voor de start van main(). Dit betekent dat voor het starten van main() de dataleden x en y van het object pg met 23en 34 worden gevuld. Daarna start main() en daarna wordt achtereenvolgens de constructor voor p1 en p2 opgeroepen. Dan pas start de uitvoering van printf(). Voor p1 en p2 is telkens een andere schrijfwijze van de initialisering toegepast.

Het is mogelijk om meerdere constructors te voorzien binnen een klasse. Het aantal en het type parameters van alle constructors moeten verschillend zijn. Met andere woorden: elke constructor heeft aan ander prototype. In de klasse Punt hadden we al een constructor met als parameters de coördinaten van een punt. We voegen nu een constructor bij die geen parameters heeft.

class Punt
{
private:
   int x;
   int y;

public:
   Punt(int ix, int iy) : x(ix), y(iy)
   {
   }
   Punt() : x(0), y(0)
   {
   }
};

De implementatie van deze nieuwe constructor plaatsen we voor het gemak in de klasse zelf. Deze constructor zorgt ervoor de dataleden x en y automatisch 0 worden als we de expliciete initialisatie weglaten bij de declaratie van een object. In de volgende versie van main zien we twee objecten van de klasse Punt; één met en één zonder initialisatie.

void main()
{
   Punt p1(30, 40);
   Punt p2;

}

Het object p1 wordt met de eerste constructor geinitialiseerd en p2 wordt geinitialiseerd met de tweede constructor. Dit betekent dat de p2.x en p2.y allebei nul worden. De compiler beslist aan de hand van het aantal en het type actuele parameters welke constructor bij de declaratie opgeroepen wordt. Dit is meteen ook de reden waarom er geen twee constructors met hetzelfde prototype mogen zijn.

Het is mogelijk om bij de declaratie een object te initialiseren met een ander object.

void main()
{
   Punt p1(30, 40);
   Punt p2 = p1;

}

We zouden kunnen verwachten dat de compiler zou eisen dat er een constructor met prototype

Punt(const Punt &x);

voorkomt in de klasse. We hoeven deze constructor echter niet te definiëren omdat dit automatisch gebeurt. Elke klasse krijgt automatisch een constructor die dient voor de initialisatie met een object van dezelfde klasse. Deze constructor wordt copy constructor genoemd; hij kopieert één voor één alle dataleden van het ene naar het andere object. Dit gedrag is hetzelfde als bij het kopiëren van structuren in C. Bij de klassen Punt is het lidsgewijs kopiëren het juiste gedrag. In het bovenstaande voorbeeld worden de datavelden x en y van p1 naar p2 gekopieerd.

Zo kunnen we ook objecten kopiëren met een toekenning. Deze operator kopieert zoals bij de copy constructor alle dataleden.

void main()
{
   Punt p1(30, 40);
   Punt p2;

   p2 = p1;
}

Voor deze bewerking heeft de compiler automatisch een operator voor de = bewerking binnen de klasse bijgevoegd. Het bijvoegen van bewerkingen bekijken we later nog wel.

De twee dataleden van de klasse Punt zijn privaat. Dit betekent dat we niet rechtstreeks toegang krijgen tot de dataleden. Daarom voegen we een klassefunctie bij die de coördinaten van een Punt op het scherm drukt.

class Punt
{
private:
   int x;
   int y;

public:
   Punt(int ix, int iy) : x(ix), y(iy)
   {
   }
   Punt() x(0), y(0)
   {
   }
   void druk();
};

void Punt::druk()
{
   cout << "<" << x <<
"," << y << ">";
}

De klassefunctie druk kan zonder meer toegang krijgen tot de dataleden van het object in kwestie. De functie druk kan alleen maar gestart worden met een concreet object:

void main()
{
   Punt p1(67,78);
   Punt p2(34,98);

   p1.druk();
   p2.druk();
}

De notatie van de oproep van een klassefunctie is dezelfde als in C voor de toegang tot een veld van een structuur. De naam van het object wordt gevolgd door een punt en de naam van de klassefunctie.

Het is mogelijk om de tijd die nodig is voor de oproep en de terugkeer van een functie te elimineren. Dit is nodig als een klassefunctie zeer kort is.

We gaan twee lidfuncties aan de klasse Punt bijvoegen om de waarden van dataleden x en y terug te geven. We tonen twee versies van de implementatie van de lidfuncties.

class Punt
{
private:
   int x;
   int y;

public:
   Punt(int ix, int iy) : x(ix), y(iy)
   {
   }
   Punt() : x(0), y(0)
   {
   }
   void druk();
   int haalx();
   int haaly();
};

int Punt::haalx()
{
   return ( y );
}

int Punt::haaly()
{
   return ( y );
}

void main()
{
   Punt pp(67, 89);

   cout << "<" << pp.haalx()
<< "," << pp.haaly() <<">\n";
}

class Punt
{
private:
   int x;
   int y;

public:
   Punt(int ix, int iy) { x = ix; y = iy; }
   Punt() { x = 0; y = 0; }
   void druk();
   int haalx()
   {
      return( x );
   }
   int haaly()
   {
      return( y );
   }
};

class Punt
{
private:
   int x;
   int y;

public:
   Punt(int ix, int iy) : x(ix), y(iy)
   {
   }
   Punt() : x(0), y(0)
   {
   }
   void druk();
   int haalx();
   int haaly();
};

inline int Punt::haalx()
{
   return ( y );
}

inline int Punt::haaly()
{
   return ( y );
}

We ontwerpen de klasse om een breuk op te slaan. De klasse krijgt twee dataleden: een voor de teller en een voor de noemer. Beide worden opgeslagen als een geheel getal. De constructor is voorzien van verstekwaarden; zo krijgt een breuk de waarde 0/1 wanneer de initialisatie ontbreekt.

// breuk.h
class Breuk
{
public:
   Breuk(int t=0, int n=1) : teller(t), noemer(n)
   {
   }
   Breuk &operator++();
   Breuk operator+(Breuk b);

private:
   int teller;
   int noemer;
};

Wanneer we een bewerkingsteken willen definiëren dan geven we de bijbehorende functie een speciale naam. We combineren het sleutelwoord operator met het bewerkingsteken in kwestie. Voor de ++ bewerking wordt dit:

Breuk &operator++();

Deze functie geeft een Breuk als referentietype terug. Dit is nodig omdat de ++ bewerking in uitdrukkingen kan voorkomen. Het terugkeer type is het referentietype omdat de ++ bewerking zowel links of rechts van een toekennig kan voorkomen.

Breuk b1;
Breuk b2;

b1++ = b2++;

Op dezelfde wijze wordt de functienaam voor deoptelling samengesteld:

Breuk operator+(Breuk b);

In dit geval is er een parameter: dit is de breuk die bij andere breuk wordt opgeteld. Het resultaat van de bewerking is het Breuk type. De bewerking kan zo gebruikt worden:

b3 = b1+b2;

We zouden de bewerlking ook als een functie kunnen starten

b3 = b1.operator+(b2);

Deze schrijfwijze is alleen maar nuttig om te zien hoe de bewerking gestart wordt.

De implementatie van beide bewerkingen worden als gewone klassefuncties geschreven. Voor de ++ bewerking wordt de noemer éénmaal bij de teller opgeteld. Met

return *this;

wordt een referentie naar het huidige object als resultaat teruggegeven.

// breuk.cpp
#include <iostream.h>
#include "breuk.h"

Breuk &Breuk::operator++()
{
   teller += noemer;
   return *this;
}

Breuk Breuk::operator+(Breuk b)
{
   Breuk nb;

   nb.teller = teller * b.noemer + noemer * b.teller;
   nb.noemer = noemer * b.noemer;

   return nb;
}

In de + bewerking wordt een nieuwe Breuk gemaakt. De som van de twee op te tellen breuken wordt in deze nieuwe variabele geplaatst. Met return, in dit geval de som, gaat het resultaat terug naar de oproeper.

In sommige gevallen is het nodig om een bewerking als een functie buiten de klasse te definiëren. Dit is het geval bij de functie die de uitvoer van een Breuk verzorgt. Omdat deze functie toegang moet krijgen tot de private leden van de klasse Breuk maken we de functie een vriend van de klasse Breuk.

friend ostream &operator<<(ostream &os, Breuk b);

Het bovenstaande prototype wordt in de klasse bijgevoegd. Met het woord friend gevolgd door een prototype wordt aangegeven dat een niet-klasse functie toegang krijgt tot alle private leden.

Voor de uitvoer wordt het naar links schuif teken << gebruikt. We schrijven dit teken na het woord operator. De parameters van de uitvoerbewerking zijn het uitvoerkanaal en de Breuk die getoond moet worden. ostream is het type van het uitvoerkanaal. cout behoort tot dit type. Als terugkeertype zien we een referentie naar ostream. We geven het uitvoerkanaal terug als referentie. Dit is nodig omdat de uitvoerbewerking samen met het uitvoerkanaal en de breuk opnieuw als een ostream aanzien wordt. Hierdoor kan men meerdere uitvoerbewerkingen na elkaar schrijven.

(cout << b1) << b2;

In de bovenstaande uitvoer wordt cout << b1 opnieuw als een uitvoerkanaal aanzien. Naar dit kanaal wordt de uitvoer van b2 gestuurd.

De implementatie van de uitvoerbewerking gaat na of de noemer 1 is. Indien ja, wordt alleen de teller getoond. Anders worden teller en noemer gescheiden met een deelstreep getoond.

ostream & operator<<(ostream &os, Breuk b)
{
   if (b.noemer == 1)
   {
      cout << b.teller;
   }
   else
   {
      cout << b.teller << "/" << b.noemer;
   }
   return os;
}

De uitvoerbewerking geeft als resultaat het doorgegeven uitvoerkanaal terug.

We tonen nog een voorbeeld van een hoofdprogramma waarin de klasse Breuk gebruikt wordt.

#include <iostream.h>
#include "breuk.h"

void main()
{
   Breuk b;

   cout << b << endl;
   b++;
   cout << b << endl;

   Breuk c(1,4);
   Breuk d(1,2);
   Breuk e;

   e = c + d;
   cout << e << endl;
}

Met de new bewerking kan geheugen op dynamische wijze gereserveerd worden. In tegenstelling tot C waar malloc() een ingebouwde functie is, is in C++ new een ingebouwde bewerking. Deze bewerking wordt toegepast op de typeinformatie.

int *pi = new int;

*pi = 5;

Punt *pu = new Punt;

Punt *pu;

pu = new Punt;

void fu()
{
   Punt *pa;
   Punt *pb;

   pa = new Punt(23,34);
   pb = new Punt(45,56);

   pa->druk();
   pb->druk();
}

Als in het voorgaande voorbeeld het einde van de functie bereikt wordt, houden de pointers pa en pb op te bestaan. Vermits ze allebei wijzen naar dynamisch gereserveerd geheugen, zou hierdoor een geheugenlek ontstaan. Daarom moet vóór het einde van de functie het geheugen vrijgegeven worden. Dit doen we met de delete bewerking.

void fu()
{
   Punt *pa;
   Punt *pb;

   pa = new Punt(23,34);
   pb = new Punt(45,56);

   pa->druk();
   pb->druk();

   delete pa;
   delete pb;
}

Na het woord delete schrijven we de naam van de pointervariabele die wijst naar het dynamisch geheugen. Voor elke new bewerking die in een programma voorkomt moet er een overeenkomstige delete bewerking zijn.

Bij het gebruik van de bewerking new bestaat de mogelijkheid om geheugen voor arrays te reserveren. We schrijven dan na new een arraytype. De waarde tussen de rechte haken mag wel een variabele zijn. Hierdoor kan de lengte van de array dynamisch bepaald zijn. In het volgende voorbeeld krijgt p het adres van een blok van 100 char's.

char *p = new char[100]
delete [] p;

Bij het vrijgeven van het geheugen met delete moet aangegeven worden dat het gaat over een array. Daarom moeten voor de variabelenaam rechte haken geschreven worden. De vrijgave van het geheugen moet expliciet geschreven worden voordat een pointervariabele ophoudt te bestaan.

Het is mogelijk om de hoeveelheid geheugen die nodig is binnen de klasse ook dynamisch te reserveren. Op deze manier zijn er geen beperkingen op de lengte van de binnen een klasse opgeslagen gegevens.

In het volgende voorbeeld wordt een klasse Tekst gedemonstreerd. Deze klassen kan gebruikt worden om tekstobjecten te creëren. Om te vermijden dat er conflicten ontstaan als er lange teksten opgeslagen moeten worden, is de opslag van de string binnen een object dynamisch. De klasse Tekst ziet er als volgt uit:

class Tekst
{
private:

   char *ptekst;

public:
   Tekst(const char *pv = "");
   ~Tekst();
   char *str() const
   {
      return( ptekst );
   }
   Tekst &operator=(const Tekst &t);
   Tekst &operator+=(const Tekst &t);
   Tekst operator+(const Tekst &t);
};

Voor de opslag van de string binnen het object is er het private datalid ptekst. De constructor

Tekst(const char *pv = "");

wordt opgeroepen als een Tekst object met een char string initialiseren. Indien de parameter bij de oproep van de constructor ontbreekt, dan wordt een lege string als verstekwaarde gebruikt.

De implementatie van de constructor is als volgt:

Tekst::Tekst(const char *pv)
{
   ptekst = new char [strlen(pv) + 1];
   strcpy(ptekst, pv);
}

Met new worden zoveel bytes gereserveerd als de string lang is. Er is ook een extra byte voor de nulwaarde op het einde. Het resultaat van strlen() is immers de lengte van de string zonder de eindnul meegerekend. De originele string wordt in het gereserveerde geheugen gekopieerd. De kopieerbewerking is nodig om ervoor te zorgen dat object een eigen string in eigendom heeft. Indien we alleen het adres van de string zouden kopiëren, dan ontstaat er een situatie waarin een object verwijst naar geheugen die niet door het object wordt beheerd. Dit zou gevaarlijke situatie zijn.

Omdat er in de constructor dynamisch geheugen wordt gereserveerd, is het nodig dat in de klasse ook een destructor bestaat. Het prototype wordt met een tilde geschreven:

~Tekst();

Een destructor heeft geen parameters en geen terugkeertype. Een destructor kan wel virtueel zijn (een constructor daarentegen niet). Ook in de implementatie komt de tilde voor.

Tekst::~Tekst()
{
   cout << "delete " << ptekst << "\n"; // alleen voor test
   delete [] ptekst;
}

In deze destructor wordt met delete het geheugen van de string vrijgegeven. De uitvoerbewerking staat er alleen maar om te kunnen zien wanneer de destructor uitgevoerd wordt en is daarom niet noodzakelijk.

Het gebruik van de klasse Tekst is als volgt:

#include <iostream.h>
#include "tekst.h"

void main()
{
   Tekst t("hallo");

   cout << t.str() << "\n";
}

De definitie van de klasse plaatsen we best in een headerbestand. Zo bevindt de definitie van Tekst zich in het bestand tekst.h. De tekst t wordt geinitialiseerd met de string "hallo". Vlak voor het einde van main() wordt de destructor opgeroepen voor het object t. met de methode str() verkrijgen we het adres van de opgeslagen tekst. De klasse Tekst kunnen we gebruiken zonder dat we iets zien van de wijze waarop de implementatie binnen de klasse is gemaakt. Deze inkapseling is één van de principes van het object georienteerd programmeren.

In het voorgaande voorbeeld is de klasse Tekst eerder beperkt. Daarom voegen we een tweetal bewerkingen bij in de klasse. We zouden deze bewerkingen kunnen bijvoegen in de vorm van klassefuncties zoals bijvoorbeeld druk() in de klasse Punt. Een ander alternatief is het veranderen van de betekenis van bewerkingstekens binnen een klasse. Dit betekent dat een bewerkingsteken een nieuwe betekenis krijgt. Volgens dit principe gaan we het = teken, += teken en het + teken koppelen aan een klassefunctie binnen de klasse Tekst. Binnen de definitie van de klasse Tekst worden de prototypes voor deze twee bewerkingen bijgevoegd.

Tekst &operator=(const Tekst &t);
Tekst &operator+=(const Tekst &t);
Tekst operator+(const Tekst &t);

Het zijn twee klassefuncties met een speciale naam. We laten het woord operator volgen door het bewerkingsteken dat we een nieuwe betekenis willen geven. De klassefuncties operator=, operator+= en operator+ hebben één formele parameter. Via deze parameter wordt de rechter-operand van de bewerking doorgegeven. De linker-operand wordt doorgegeven via de impliciete pointer naar het object. Met de plus operator kunnen we dan schrijven:

Tekst t1("dag ");
Tekst t2("wereld");
Tekst t3("");

t3 = t1 + t2;

Deze 'optelling' zou ook als volgt geschreven kunnen worden:

t3 = t1.operator+(t2);

Deze schrijfwijze is niet zo goed leesbaar, maar geeft wel duidelijk weer hoe de twee operands aan de optelling worden doorgegeven. De implementaties van de = en += bewerkingen zien er zo uit:

Tekst &Tekst::operator=(const Tekst &t)
{
   delete ptekst;// verwijder de oude tekst
   ptekst = new char [strlen(t.str() ) + 1]; // ruimte voor nieuwe tekst
   strcpy(ptekst, t.str() );// kopieer tekst
   return( *this );
}

Tekst &Tekst::operator+=(const Tekst &t)
{
   char *poud;

   poud = ptekst;// hou oude tekst opzij

// reserveer ruimte voor nieuwe tekst
   ptekst = new char [strlen(poud) + strlen(t.str() ) + 1];

   strcpy(ptekst, poud);// kopieer eerste tekst
   strcat(ptekst, t.str() ); // voeg tweede tekst erbij
   delete poud;// verwijder oude tekst
   return( *this );
}

Bij elk van de twee bewerkingen wordt opnieuw dynamisch geheugen gereserveerd omdat de lengte van de nieuwe tekst, die in een object opgeslagen wordt, groter kan zijn dan de oude tekst. Telkens wordt het betrokken object via return teruggegeven. Dit is nodig omdat het resultaat van de bewerking ook van het type Tekst is.

De + bewerking kan kort geschreven worden:

Tekst Tekst::operator+(const Tekst &t)
{
   Tekst nt;// nieuwe tekst

   nt = *this;// kopieer eerste tekst
   nt += t;// voeg tweede tekst bij
   return( nt );// geef nieuwe tekst terug als resultaat
}

We maken gebruik van een lokaal Tekst object nt. Met een toekenning en daarna += bewerking worden de twee bronteksten samengevoegd in een nieuwe tekst. Deze nieuwe tekst wordt als resultaat teruggegeven. In de + bewerking wordt gebruik gemaakt van de eerder ontworpen = en += bewerkingen. Het terugkeer type is in dit geval géén referentietype.

Het gebruik van de klasse Tekst is als volgt:

#include <iostream.h>
#include "tekst.h"


void main()
{
   Tekst t("hallo");
   Tekst t2;
   Tekst t3("o");

   cout << t.str() << "\n";
   t2 = t;
   t2 = t + t3;
   cout << t2.str() << "\n";
}

Merk op dat er een verschil is tussen de twee bewerkingen met het = teken in het volgende fragment:

{
   Tekst ta("1234");
   Tekst tb = ta;
   Tekst tc("");

   tc = ta;
}

Bij het eerste = teken wordt de copyconstructor gestart om tb te initialiseren; bij het tweede = teken wordt de klassefunctie operator=() gestart. Let op: de copyconstructor hebben we niet zelf bijgevoegd in de klasse Tekst. Daarom wordt de default copyconstructor uitgevoerd. Deze is evenwel niet geschikt voor gebruik van zodra binnen een klasse zelf dynamisch geheugen wordt bijgehouden. Dit is de reden waarom het bovenstaand fragment problemen kan geven zolang geen eigen versie van de copyconstructor binnen de klasse Tekst wordt bijgevoegd.

We maken een basisklasse die gaat dienen voor de opslag van een waarde. Als klassenaam kiezen we de naam Waarde. De eerste letter is een hoofdletter, bijgevolg is dit een klassenaam. Deze klasse moet dienen om een waarde van een nog niet gekend type op te slaan. We wensen nu nog niet vast te leggen welk type gebruik zal worden want dan zou de klasse Waarde niet algemeen bruikbaar zijn. De klasse Waarde zou moeten kunnen werken met elk mogelijk getaltype.

class Waarde
{
private:
    // geen datalid

public:
   // hier plaatsen we de vrij toegankelijke klassefuncties
};

De beslissing om geen datalid voor de waarde in de klasse Waarde te plaatsen is een goede beslissing. We kunnen immers het datalid voor de waarde in de afgeleide klassen plaatsen. De klasse Waarde is bedoeld als basisklasse. We zullen van deze klasse nooit objecten maken. Zo komen we meteen tot het begrip abstracte klasse. een abstracte klasse is niet bedoeld om er concrete objecten mee te maken maar wel om een algemeen gedrag te bepalen voor een reeks afgeleide klassen.

Bij dit voorbeeld is het gewenste algemeen gedrag van de klasse Waarde de mogelijkheid om de opgeslagen waarde op het scherm te drukken. Daarom plaatsen we een klassefunctie druk() in het publieke gedeelte.

class Waarde   // abstracte klasse
{
public:
   virtual void druk() = 0;
};

De schrijfwijze van het prototype van druk() vertoont twee nieuwe elementen:

Met het woord virtual geven we aan dat druk() een virtuele functie is. De precieze werking wordt later duidelijk. Na druk() staat er = 0. Hiermee geven we aan dat we voor druk() nog geen implementatie voorzien. Deze implementatie moet ingevuld worden in de verschillende afleidingen van de basisklasse. Deze = 0 is niet nodig om de functie virtueel te maken maar wel om de klasse abstract te maken.

Van een abstracte klasse mogen we geen objecten maken. Wel is het mogelijk om een pointer of een referentie naar een abstracte klasse te maken.

Waarde w1;// FOUT
Waarde *pw1// GOED

We maken twee afleidingen van de basisklasse. Een voor de opslag van een geheel getal en een voor de opslag van een reëel getal.

class IWaarde : public Waarde
{
private:
   int intwaarde;

public:
   IWaarde(int iw) : intwaarde(iw)
   {
   }
   virtual void druk();
};

class FWaarde : public Waarde
{
private:
   double floatwaarde;

public:
   FWaarde(double iw) : floatwaarde(iw)
   {
   }
   virtual void druk();
};

Elke van deze afleidingen krijgt een privaat datalid voor de opslag van de waarde. Het type van de waarde is telkens verschillend. In elke afgeleide klasse is er een constructor voorzien om het object te initialiseren. In elke afgeleide klasse wordt ook het prototype van druk() bijgevoegd. Dit betekent dat de functionaliteit van de functie druk() in de verschillende afgeleide klassen willen invullen. Het woord virtual wordt herhaald voor het prototype, dit is niet verplicht. Wel is het verplicht om bij het herdefiniëren van een virtuele functie in een afgeleide klasse dezelfde formele parameters te voorzien als in de basisklasse.

De twee druk() functies verschillen omdat de te drukken waarden van een ander type zijn:

void IWaarde::druk()
{
   cout << "geheel " << intwaarde;
}

void FWaarde::druk()
{
   cout << "reeel " << floatwaarde;
}

In programmeertalen zoals Pascal, C en C++ is er een strikte typecontrole door de compiler. De omzetting van het ene type naar het andere type is niet altijd toegelaten. Op enkele uitzonderingen na is het verboden om verschillende types te gebruiken in toekenningen. In C en C++ kan deze beperking natuurlijk omzeild worden door de geforceerde omzetting (cast), maar deze programmeertechniek is niet elegant en veroorzaakt veel sneller fouten op. In C++ wordt de cast-bewerking grotendeels overbodig door de mogelijkheid om in beperkte mate toch toekenningen te doen tussen verschillende types.

In C++ is het toegelaten om een toekenning te doen van pointers (dit geldt ook voor het referentietype) van een verschillende type. Er is wel een voorwaarde: de pointer aan de linkerzijde van de toekenning moet van een type zijn dat als superklasse voorkomt van de klasse van de pointer aan de rechterzijde van de toekenning. Deze uitzondering is de enige op de regel die zegt dat de twee types aan beide zijden van een toekenning gelijk moeten zijn.

Een voorbeeld maakt dit duidelijk:

Waarde *pw;
IWaarde *piw;
FWaarde *pfw;

pw = piw;   // ok, Waarde is de basisklasse van IWaarde
pw = pfw;   // ok, Waarde is de basisklasse van FWaarde
piw = pw;   // fout, Iwwaarde is geen basisklasse van Waarde

Deze compatibiliteit tussen verschillende pointertypes is nodig om gebruik te kunnen maken van de virtuele functies. Ter verduidelijking is hier nog het schema dat het verband tussen de verschillende klassen uit het voorbeeld weergeeft.

Figuur 8.1. Twee klassen met een gemeenschappelijke superklasse

Als we een virtuele klassefunctie oproepen via een pointer naar de basisklasse komt effect van de virtuele functie tot uiting.

IWaarde i1(5);
FWaarde f1(7.9);
Waarde *pw;

pw = &i1;
pw->druk();
pw = &f1;
pw->druk();

De pointer pw is een pointer naar een Waarde object. De declaratie en het gebruik van pw is toegelaten. Objecten van een abstracte klasse mogen niet, pointers naar een abstracte klasse mogen wel. Bij de eerste toekenning wijst pw naar een IWaarde object. Bij de oproep van druk() wordt de IWaarde variant van druk() gestart. Op het scherm verschijnt 5. Bij de tweede toekenning wijst pw naar een FWaarde object. Bij de tweede oproep van druk() wordt de FWaarde variant van druk() gestart. Op het scherm verschijnt 7.9. In elk object van een klasse met tenminste één virtuele functie zit extra informatie opgeslagen over de klasse van het object. Door deze informatie is het mogelijk dat bij de oproep van druk() bepaald wordt welke variant uit een van de afgeleide klassen wordt gestart.

Dit is de volledige tekst van het voorbeeld:

#include <iostream.h>

class Waarde   // abstracte klasse
{
public:
   virtual void druk() = 0;
};

class IWaarde : public Waarde
{
private:
   int intwaarde;

public:
   IWaarde(int iw) : intwaarde(iw)
   {
   }
   virtual void druk();
};

class FWaarde : public Waarde
{
private:
   double floatwaarde;

public:
   FWaarde(double iw) : floatwaarde(iw)
   {
   }
   virtual void druk();
};

void IWaarde::druk()
{
   cout << "geheel " << intwaarde;
}

void FWaarde::druk()
{
   cout << "reeel " << floatwaarde;
}

void toon(Waarde *pw)
{
   pw->druk();
}

void main()
{
   //Waarde ww;    fout Waarde is een abstracte klasse
   IWaarde i1(5);
   FWaarde f1(7.9);
   toon( &i1 );
   toon( &f1 );

   Waarde *pw1 = new IWaarde(256);
   Waarde *pw2 = new FWaarde(1.0/3.0);
   pw1->druk();
   pw2->druk();
}

In het voorbeeld wordt het principe van de virtuele functie tweemaal gedemonstreerd. Eenmaal worden adressen van objecten aan de functie toon() doorgegeven. De functie toon is ontwerpen met het doel de waarde van het doorgegeven object te tonen. Het object wordt doorgegeven via zijn adres. Dit is efficiënter dan de volledige waarde door te geven. De functie toon() verwacht het adres van een Waarde object. Vermits Waarde een abstracte basisklasse is van IWaarde of FWaarde, kan het doorgegeven object een IWaarde of een FWaarde object zijn. Gezien vanuit de functie toon() kan niet op voorhand voorspeld worden of het doorgegeven object een IWaarde of een FWaarde. Dit is de reden waarom we een virtuele functie gebruiken als mechanisme voor de start van druk(). Binnen toon() is er geen kennis nodig over de mogelijke specialisaties van Waarde. We kunnen dit voorbeeld besluiten met te zeggen dat een Waarde object toonbaar is; de waarde van het object kan verschillend zijn in de verschillende afleidingen. Dit verschil in gedrag wordt vastgelegd in de implementatie van de afgeleide klassen.

In dit voorbeeld wordt het gebruik van vector getoond.

#include <vector>

using namespace std;

class Punt
{
private:
  int x;
  int y;

public:
  Punt(int ix, int iy) : x(ix), y(iy)
  {
  }

  void toon()
  {
    printf("%d, %d\n", x, y);
  }
};


int main()
{
   vector<Punt *> lijst;

   for (int i=0; i<20; i++)
   {
      Punt *p = new Punt(1+i,2+i);
      lijst.push_back(p);
   }



   for (int i= 0;i<lijst.size(); i++)
   {
      lijst[i]->toon();
   }

   vector<Punt *>::iterator it = lijst.begin();
   while (it != lijst.end())
   {
     Punt *q = *it;
     q->toon();

     it++;      
   }


   for (int i= 0;i<lijst.size(); i++)
   {
      delete lijst[i];
   }
}

Hier is het voorgaande voorbeeld overgenomen en vector door list vervangen. De herhaling waarbij de rechte haken [] worden gebruikt voor indexering is geschrapt. Bij list en andere containers is dit niet mogelijk.

#include <list>

using namespace std;

class Punt
{
private:
  int x;
  int y;

public:
  Punt(int ix, int iy) : x(ix), y(iy)
  {
  }
  ~Punt()
  {
    printf("~Punt\n");
  }

  void toon()
  {
    printf("%d, %d\n", x, y);
  }
};


int main()
{
   list<Punt *> lijst;

   for (int i=0; i<20; i++)
   {
      Punt *p = new Punt(1+i,2+i);
      lijst.push_back(p);
   }

   list<Punt *>::iterator it = lijst.begin();
   while (it != lijst.end())
   {
     Punt *q = *it;
     q->toon();

     it++;      
   }


   it = lijst.begin();
   while (it != lijst.end())
   {
     Punt *q = *it;
     delete q;

     it++;      
   }

}

In dit voorbeeld wordt een ingenieus systeem toegepast om geheugenlekken op te sporen. Elke klasse moet afgeleid worden van GElem. Er moet ook een enkel globaal GLijst gemaakt worden. Op het einde van het programma wordt automatisch gemeld welke objecten nog niet vrijgegeven worden.

// dbg-geheugen.h

// $Date: 2005/02/04 10:15:11 $

#ifndef DBG_GEHEUGEN

#include <stdio.h>
#include <list>

using namespace std;

// deze klasse is een element bedoeld om in een lijst 
// op te slaan. Omdat vanuit deze klasse verwezen
// wordt naar de lijst klasse en omdat dit compilatiefouten
// geeft, wordt de lijstklasse als parameter class T doorgegeven

template<class T>
class GElem_tm     // dit is de elementklasse met template parameter
{
public:
   GElem_tm()
   {
      printf("GElem()\n");
      T::haal().voegbij(this); // T wordt GLijst
   }
   ~GElem_tm()
   {
      printf("~GElem()\n");
      T::haal().verwijder(this); // T wordt GLijst
   }
   
   // deze functie moet een andere invulling
   // krijgen in de afleiding
   virtual void toon()
   {
      printf("GElem\n");
   }
};

class GLijst;  // voorwaartse declaratie van een klasse
               // hiermee wordt de compiler verteld dat
               // deze naam een klasse is

          // dit is de elementklasse met template parameter
          // de actuele parameter is GLijst
typedef GElem_tm<GLijst> GElem;      


// de klasse GLijst houd een lijst van GElem bij
// elke in de toepassing gebruikte klasse
// moet overerven van GElem

class GLijst
{
public:
   GLijst()
   {
      printf("GLijst()\n");
   }
   void voegbij(GElem *em)
   {
      lijst.push_back(em);
   }
   void verwijder(GElem *em)
   {
      lijst.remove(em);
   }
   void toon()
   {
      printf("GLijst:\n");

      printf("lijst van nog niet vrijgegeven objecten\n");
      
      list<GElem *>::iterator it = lijst.begin();
      while (it != lijst.end())
      {
         GElem *q = *it;
         q->toon();

         it++;      
      }

   }
   ~GLijst()
   {
      printf("~GLijst\n");
      list<GElem *>::iterator it = lijst.begin();
      while (it != lijst.end())
      {
         printf("element vergeten vrij te geven\n");
         GElem *q = *it;
         q->toon();
         
         
      /* deze delete zorgt erook voor dat het GElem uit
         de lijst verwijderd is. Om problemen te vermijden 
         met it laten we it steeds naar het begin van de lijst 
         wijzen
         e
       */
         // verwijder GElem uit lijst en geheugen
         delete *it;

         // het begin van de lijst is veranderd, daarom opnieuw instellen 
         it = lijst.begin();
         
         // dit zou fout zijn
         //  it++;      
      }
   }

   
   // deze functie geeft een referentie naar het
   // ene en enige GLIijst object terug
   static GLijst &haal()
   {
       return geheugen;
   }
   // dit is een statisch GLijst object    
   static GLijst geheugen;
   
private:
   list<GElem *> lijst;
};

#endif

// $Date: 2005/02/04 10:15:11 $

#include <stdio.h>
#include "dbg-geheugen.h"


using namespace std;

// dit is een klasse die getest wordt
// tegen geheugenlekken, vandaar
// de erfenis van GElem

class Punt : public GElem
{
private:
  int x;
  int y;

public:
  Punt(int ix, int iy) : x(ix), y(iy)
  {
  }
  ~Punt()
  {
    printf("~Punt\n");
  }

  void toon()
  {
    printf("Punt: %d, %d\n", x, y);
  }
};


// dit is het object met daarin de lijst
// de contsructor en destructor worden
// automatisch gestart
GLijst GLijst::geheugen;

int main()
{
   printf("start\n");
   
   Punt *p1 = new Punt(5,6);
   Punt *p2 = new Punt(7,8);
   Punt *p3 = new Punt(10,10);
   

   // deze toon geeft al aan dat er
   // Punt objecten in het geheugen
   // zitten
   GLijst::geheugen.toon();
   printf("einde\n");
   
   // nadat deze accolade overschreden is,
   // wordt de destructor van GLijst gestart
   // en die meldt dat er nog 3 objecten
   // in het geheugen zitten
}

Dit is een klein Qt voorbeeld met een paint() functie.

#include <qapplication.h>
#include <qpushbutton.h>
#include <qfont.h>
#include <qpainter.h>


class MyWidget : public QWidget
{
public:
    MyWidget( QWidget *parent=0, const char *name=0 );

protected:
    void paintEvent( QPaintEvent * );
};


MyWidget::MyWidget( QWidget *parent, const char *name )
        : QWidget( parent, name )
{
    setMinimumSize( 200, 120 );
    setMaximumSize( 200, 120 );

    QPushButton *quit = new QPushButton( "Quit", this, "quit" );
    quit->setGeometry( 62, 40, 75, 30 );
    quit->setFont( QFont( "Times", 18, QFont::Bold ) );

    connect( quit, SIGNAL(clicked()), qApp, SLOT(quit()) );
}

void MyWidget::paintEvent( QPaintEvent * )
{
    QString s = "Hallo";
    QPainter p( this );
    p.drawText( 20, 20, s );
}


int main( int argc, char **argv )
{
    QApplication a( argc, argv );

    MyWidget w;
    w.setGeometry( 100, 100, 200, 120 );
    a.setMainWidget( &w );
    w.show();
    return a.exec();
}

Figuur 19.1. UML Diagramma van het Figuren voorbeeld

/****************************************************************
**
** Qt figuren vb
**
****************************************************************/

#include <qapplication.h>
#include <qpushbutton.h>
#include <qfont.h>
#include <qpainter.h>
#include <vector>

using namespace std;


class Figuur
{
public:
   Figuur(int ix, int iy) : x(ix), y(iy)
   {
   }
   virtual void teken(QPainter *p, int dx, int dy) = 0;
   
protected:
   int x;
   int y;
};

class Lijn : public Figuur
{
public:
   Lijn(int ix1, int iy1, int ix2, int iy2) : Figuur(ix1, iy1), x2(ix2), y2(iy2)
   {
   }

   void teken(QPainter *p, int dx, int dy);
   
private:
   int x2;
   int y2;
};

class Rechthoek : public Figuur
{
public:
   Rechthoek(int ix1, int iy1, int ix2, int iy2) : Figuur(ix1, iy1), x2(ix2), y2(iy2)
   {
   }
   
   void teken(QPainter *p, int dx, int dy);

private:
   int x2;
   int y2;
};




class SFiguur : public Figuur
{
public:
   SFiguur(int ix, int iy) : Figuur(ix, iy)
   {
   }
   void voegbij(Figuur *f);
   void teken(QPainter *p, int dx, int dy);

private:
   vector<Figuur *> figuren;
};



void SFiguur::voegbij(Figuur *f)
{
   figuren.push_back(f);
}

void Lijn::teken(QPainter *p, int dx, int dy)
{
   p->drawLine(dx + x, dy + y, dx + x2, dy + y2);
}

void Rechthoek::teken(QPainter *p, int dx, int dy)
{
   p->drawRect(dx + x, dy + y, x2 - x, y2 - y);
}

void SFiguur::teken(QPainter *p, int dx, int dy)
{
   for (int i= 0;i<figuren.size(); i++)
   {
      figuren[i]->teken(p, dx + x, dy + y);
   }
}

class FVenster : public QWidget
{
public:
    FVenster( QWidget *parent=0, const char *name=0 );

protected:
    void paintEvent( QPaintEvent * );

private:
   SFiguur *fig;    
};


FVenster::FVenster( QWidget *parent, const char *name )
        : QWidget( parent, name )
{
    setMinimumSize( 400, 300 );
    setMaximumSize( 400, 300 );

    // maak een SFiguur
    fig = new SFiguur(100, 100);
    fig->voegbij(new Rechthoek(0, 30, 30, 60));
    fig->voegbij(new Lijn(0, 30, 15, 0));
    fig->voegbij(new Lijn(15, 0, 30, 30));
}

void FVenster::paintEvent( QPaintEvent * )
{
    QString s = "Hallo";
    QPainter p( this );
    
    fig->teken(&p, 0, 0);
}


int main( int argc, char **argv )
{
    QApplication a( argc, argv );

    FVenster w;
    w.setGeometry( 100, 100, 200, 120 );
    a.setMainWidget( &w );
    w.show();
    return a.exec();
}

Dit is de Makefile om beide voorbeelden te compileren. Je ziet dat er gelinkt wordt met de qt bibliotheek die zich in de directory /usr/lib/qt/lib bevindt.

gpainter: qpainter.o
	g++ -o qpainter qpainter.o -L/usr/lib/qt/lib -lqt

qpainter.o: qpainter.cpp
	g++ -c qpainter.cpp

figuren: figuren.o
	g++ -o figuren figuren.o -L/usr/lib/qt/lib -lqt


figuren.o: figuren.cpp
	g++ -c figuren.cpp