C++ voor C-kenners Jeroen Fokker Informatica Instituut Universiteit Utrecht januari 1995 De taal C++ wordt steeds meer gebruikt als alternatief voor C. De taal is een object-geori¨enteerde uitbreiding van C. Het blijft dus mogelijk om alle constructies uit C te gebruiken, waardoor de taal voor C-programmeurs gemakkelijk te leren is. Het is echter aan te raden om sommige constructies en programmeertechnieken niet meer te gebruiken, omdat er betere voor in de plaats beschikbaar zijn. Deze tekst geeft een overzicht van de belangrijkste verschillen tussen C en C++. Eerst worden de nieuwe of uitgebreide taalconstructies uit C++ behandeld. In hoofdstuk 2 en 4 wordt het belangrijkste nieuwe concept, de class, behandeld; dit wordt onderbroken door een aantal voorbeelden in hoofdstuk 3. In hoofdstuk 5 worden de belangrijkste aspecten van de nieuwe input/output library besproken.
1 1.1
Nieuwe taalconstructies Commentaar
De manier waarop commentaar wordt aangegeven is een niet erg belangrijk, maar wel in het oog lopend verschil tussen C en C++. In C begint commentaar met /* en eindigt met */. Bijvoorbeeld: /* Deze functie berekent de omtrek van een cirkel */ float omtrek(float r) { /* r is de straal */ return (2*pi*r); }
In C++ is er nog een tweede manier om commentaar aan te duiden: commentaar begint met // en eindigt aan het eind van de regel. Bijvoorbeeld: // Deze functie berekent // de omtrek van een cirkel float omtrek(float r) { // r is de straal return (2*pi*r); }
Hiermee is ‘uitcommentari¨eren’ van een regel makkelijker geworden. De oude commentaar-stijl blijft ook geldig.
1.2
Constanten
In C kun je met #define constanten defini¨eren: #define pi 3.14159 #define false 0
1
Deze definities worden ge¨expandeerd door een preprocessor van de compiler. De eigenlijke compiler ziet dus gewoon de numerieke waarden staan. Daarom zijn aldus gedefinieerde constanten ook toegestaan in bijvoorbeeld array-declaraties. Dat #define inderdaad door een preprocessor wordt behandeld, blijkt uit het feit dat je er de taal mee kunt veranderen: #define als if
Daarna lijkt de taal een als-statement te kennen. Constanten defini¨eren is handig, maar hoort eigenlijk in de taal zelf thuis, en niet in de preprocessor. Andere namen verzinnen voor keywords is enigzins vergezocht, en kun je eigenlijk beter niet gebruiken. In C++ is er daarom een constructie om constanten te defini¨eren, die beter aansluit op variabele-declaraties. Ze zien er uit als een initialiserende variabele-declaratie, voorafgegaan door het keyword const: const float pi = 3.14159; const int false = 0;
Constante pointers zijn nu ook mogelijk: const int *pf
=
&false;
Extra voordeel is dat deze constanten getypeerd zijn. Voor het defini¨eren van constanten is de preprocessor dus niet meer nodig.
1.3
Inline functies
In C kunnen macros gedefinieerd met #define voorzien zijn van parameters. Je kunt hier een soort functies mee defini¨eren: #define square(x)
x*x
Ook hier wordt de substitutie door de preprocessor uitgevoerd. Als de macro dus gebruikt wordt met square(1+2) dan wordt er code gegenereerd voor de expressie 1+2*1+2. Je ziet hier meteen het nadeel: door de syntactische substitutie is het resultaat niet 9 (het kwadraat van 1+2) maar 5. Een C-programmeur die dit een paar keer meegemaakt heeft zal daarom liever defini¨eren: #define square(x)
((x)*(x))
maar dat blijft lapwerk. De enige reden om zo’n definitie te schrijven in plaats van een gewone functieaanroep, is effici¨entie: je spaart een functieaanroep uit (ten kost van een langere objectcode). In C++ is dit eleganter opgelost. Je mag bij elke functie erbij schrijven dat de functie ‘inline’ is. Voor inline-functies wordt niet apart code gegenereerd, maar wordt de body ge¨expandeerd bij elke aanroep. De definitie van een tijd-effici¨ente kwadraatfunctie is dus: inline int square(int x) { return x*x; }
Voordeel is dat je door toevoegen en weghalen van het woord inline gemakkelijk kunt wisselen tussen een tijd- en een ruimte-effici¨ente versie. Bovendien worden de functies altijd gecontroleerd op syntax en type.
1.4
Declaraties
In oude versies van C mochten lokale variabelen alleen maar gedefinieerd worden aan het begin van een functie. In ANSI-C mogen variabelen aan het begin van elk blok gedefinieerd worden, dus na elke accolade openen. In C++ zijn er helemaal geen voorwaarden meer aan de plaats van declaraties. Statements en declaraties mogen elkaar dus vrijelijk afwisselen. Voordeel is dat je declaraties dichtbij het gebruik kunt zetten, en gemakkelijk delen van een functie, compleet met declaraties, kunt verplaatsen. Je kunt zelfs een loop-teller ter plaatse declararen: for (int i=1; i<10; i++) p(i);
2
Nadeel is dat de declaraties minder gemakkelijk te vinden zijn. Veel programmeurs blijven de declaraties daarom aan het begin zetten.
1.5
Typedeclaraties
Structures zijn altijd een beetje lastig geweest in C. Op de plaats van een type mag je schrijven struct naam. Bij het eerste gebruik moeten ook de velden worden opgesomd. In het volgende voorbeeld wordt een variabele p van het type struct punt gedeclareerd (waarbij, omdat dit het eerste gebruik is, de velden worden opgesomd). Later wordt het type nog eens gebruikt in een parameter-declaratie. De velden hoeven nu niet meer te worden opgesomd: struct punt {int x; int y;} p; void f(struct punt q);
In een variabele-declaratie mag je ook nul variabelen declareren. Meestal is dat natuurlijk onzin, maar veel mensen gebruiken dit om alvast maar de velden van een structure op te sommen: struct punt {int x; int y}; struct punt p;
Vervelend blijft dat je steeds het woord struct moet herhalen. Daarom is in C een typedef mogelijk: typedef struct punt {int x; int y; } PUNT; void f(PUNT p);
omslachtig is dat je nu twee namen moet verzinnen: punt en PUNT. Het nieuwe type is PUNT, terwijl struct punt nu alleen nog maar nodig is voor recursieve typedefinities. Omdat dit allemaal maar ingewikkeld is, is het in C++ toegestaan om de naam achter struct, ook zonder typedef, te gebruiken als typenaam: struct punt {int x; int y}; void f(punt p);
1.6
// eeste gebruik
Call bij reference
In C is het lastig om variabelen door een functie te laten veranderen. Je moet dan een pointer naar die variabele als parameter gebruiken. Bij aanroep moet je dan ook het adres van de variabele meegeven, in plaats de waarde ervan. Bijvoorbeeld de bekende wissel-functie: void wissel( int *x; int *y) { int h; h = *x; *x = y; *y = h; } main() { int a, b; wissel( &a, &b ); }
In C++ kun je bij declaratie van de functie aangeven dat de parameter by reference meegegeven moet worden. In de body van die functie hoef je dan geen sterretjes meer te zetten, en wat belangrijker is: bij de aanroep hoef je de adres-operator niet meer te gebruiken: void wissel( int &x; int &y) { int h; h = x; x = y; y = h; } main() { int a, b; wissel( a, b ); }
Qua implementatie gebeurt er overigens precies hetzelfde. Daarmee is ook duidelijk waarom in 3
C++ de eis wordt gesteld dat bij aanroep van een functie het type bekend is: dit is van belang om te weten welke code gegenereerd moet worden voor wissel(a,b).
1.7
Overloading
Als je in C een functie wilt schrijven op verschillende typen, moet je verschillende namen verzinnen: int iabs(int x) { return (x<0 ? } float fabs(float { return (x<0.0 } main() { ... iabs(3) + }
-x : x); x) ? -x : x);
fabs(-2.7) ...
In C++ mag je dezelfde naam gebruiken, mits de parameters van verschillend type zijn. Voor een functie-aanroep wordt door de compiler op grond van het type de juiste functie gekozen: int abs(int x) { return (x<0 ? -x : x); } float abs(float x) { return (x<0.0 ? -x : x); } main() { ... abs(3) + abs(-2.7) ... }
1.8
Default-parameters
Met overloading kun je handige dingen doen. Bijvoorbeeld een machtsverhef-functie met twee parameters: float macht(float x; int n) { r = 0; for (i=0; i
en een aparte versie daarvan, waarbij de tweede parameter is weggelaten: float macht(float x) { return macht(x,2); }
Op deze manier zal macht als ‘default’-waarde voor de exponent 2 gebruiken. Nog handiger is het, dat je dit in C++ in ´e´en declaratie kunt aangeven: float macht(float x; int n=2) { r = 0; for (i=0; i
Parameters waarvoor je een default-waarde wilt specificeren, moeten aaneengesloten aan het eind van de parameterlijst staan.
4
1.9
Operator overloading
Behalve functies mag je in C++ ook zelf operatoren defini¨eren. De naam van de operator moet die van ´e´en van de standaardoperatoren zijn, zodat er altijd sprake is van overloading. De definitie ziet er hetzelfde uit als een functiedefinitie, behalve dat aan de naam het woord operator vooraf gaat. Als je zelf bijvoorbeeld een type Complex gemaakt hebt, kun je daarop de operator + als volgt defini¨eren: Complex operator + (Complex a, Complex b) { return makecomplex( a.re+b.re, a.im+b.im ); }
De volgende binaire operatoren mogen overloaded worden: && = <
|| ++ >
-<=
+ += >=
-= ==
* *= !=
/ % /= %= ->* ,
^ ^=
& &=
| |=
<< >> <<= >>=
en de volgende unaire operatoren: -
~
!
Bovendien mogen de volgende symbolen overloaded worden als binaire operator: ->
[]
()
new
delete
Daarmee zijn zelfs ‘dereferencing’, array-indicering (zie sectie 3.3), functie-aanroep, en objectcreatie en -deletie (zie sectie 1.10) te overloaden.
1.10
Dynamische allocatie
In C levert de standaardfunctie malloc een blok geheugen van een bepaalde lengte. Het resultaat is van type void* en moet gecast worden naar het juiste type. Omdat pointers ook ge¨ındiceerd mogen worden, kun je hiermee arrays maken met een lengte die voor de compiler nog niet bekend is: int *data; data = (int*) malloc( n * sizeof(int) ); f(data[4]); free(data);
Het aantal te alloceren bytes is het aantal gewenste elementen n vermenigvuldigd met de afmeting van ´e´en element. De geheugenruimte wordt vrijgegeven met de standaardfunctie free. In C++ kan geheugen worden gealloceerd met het keyword new, gevolg door een type. Anders dan bij gewone declaraties mag als arraygrens hierbij een niet-constante expressie gebruikt worden. Een cast, zoals in C, is nu niet meer nodig. De geheugenruimte wordt weer vrijgegeven met het keyword delete: int *data; data = new int[n]; f(data[4]); delete data;
2 2.1
Classes Abstracte datatypen in C
In elke cursus over datastructuren leer je dat het handig is om eerst een type te defini¨eren, en vervolgens een aantal functies die op dat type werken. Dat type is meestal een structure met een heleboel velden. Het wordt een ‘abstract type’ als je belooft variabelen van dit type alleen maar met behulp van de daarvoor bedoelde functies te gebruiken, en dus niet zelf in de structure gaat spitten. 5
In C zou je als volgt een stack kunnen defini¨eren. De implementatie bestaat uit een structure met een array en een integer die aangeeft hoe ver die array gevuld is. In de typedefinitie permitteren we ons alvast de C++-notatie zoals besproken in sectie 1.5: struct stack { char info[100]; int top; };
Op dit type werken de functies reset, push en pop, die dus alledrie een stack als parameter hebben. Omdat de stack ook veranderd wordt (althans bij reset en push) wordt een pointer naar de datastructuur meegegeven, en niet de structuur zelf: void reset(stack *s) { s->top = -1; } void push(stack *s, char c) { s->top++; s->info[s->top] = c; } char top(stack *s) { return s->info[s->top]; }
Bij het schrijven van deze functies ontkomen we er natuurlijk niet aan om de opbouw van de struct te kennen. In het hoofdprogramma wordt men geacht alleen de abstracte operaties te gebruiken: main() { stack stapel; /* netjes gebruik */ reset(&stapel); push(&stapel,’a’); /* stiekem gebruik */ stapel.info[73] = ’x’; }
Helaas is het niet af te dwingen dat een gebruiker zich aan de belofte houdt om het type alleen te benaderen via de daarvoor bedoelde functies. In het voorbeeld wordt de belofte in het laatste statement gebroken. Dat is vervelend, want als je de implementatie zou vervangen door een andere (bijvoorbeeld met een lineaire lijst in plaats van een array), dan geeft het hoofdprogramma ineens een fout in de laatste regel.
2.2
Abstracte datatypen in C
In C++ kunnen de functies die op een bepaald datatype werken gedefinieerd worden in de typedefinitie van de structure: struct stack { private: char info[100]; int top; public: void reset(void) { top = -1; } void push(char c){ top++; info[top]=c; } char top(void) { return info[top]; } };
Je hoeft niet meer op te schrijven dat deze functies een stack als parameter hebben. In de body van de functies kun je top en info direct gebruiken, zonder daarbij steeds s-> te hoeven schrijven. Bij aanroep van de functies moet wel duidelijk gemaakt worden op welke stack nu eigenlijk de ope6
raties toegepast moeten worden. Daarvoor wordt de punt-notatie gebruikt; per slot van rekening staan de definities van de functies ‘in’ de structure-definitie, en kunnen ze dus ook ‘geselecteerd’ worden: main() { stack stapel; stapel.reset(); stapel.push(’a’); }
In C++ declareer je in een structure-definitie naast data ook functies. Deze functies worden de memberfuncties van de structure genoemd. Met de keywords private en public kun je bovendien aangeven hoe de data en functies gebruikt mogen worden: • private: mogen alleen door de memberfuncties gebruikt worden • public: zijn ook door buitenstaanders bereikbaar met de punt-notatie Doordat in het voorbeeld de velden top en data achter private: staan, mogen ze alleen door de memberfuncties gebruikt worden. In het hoofdprogramma kan er dus geen misbruik van gemaakt worden. De drie memberfuncties zijn allemaal public, en mogen dus w`el in het hoofdprogramma gebruikt worden. Er zijn echter ook memberfuncties denkbaar die alleen als hulpfunctie zijn bedoeld voor de andere memberfuncties, en die niet van buitenaf gebruikt mogen worden. Die worden dan in het private deel neergezet. Als je eraan twijfelt wat een memberfunctie nu precies inhoudt, dan is het misschien handig om je de implementatie ervan voor te stellen. De code die wordt gegenereerd voor het voorbeeld uit deze sectie is namelijk precies hetzelfde als die voor het C-programma uit de vorige sectie. Dat wil zeggen: • het gebruik van private en public be¨ınvloedt alleen de scope van de naam van velden, en is voor codegeneratie niet van belang; • memberfuncties worden niet echt opgeslagen in variabelen; • memberfuncties hebben stiekem een extra parameter, namelijk een pointer naar de betreffende structure. Waar een memberfunctie de member-variabele x gebruikt, wordt eigenlijk p->x gebruikt, waarbij p de extra meegegeven pointer is.
2.3
Classes
Een class in C++ is vrijwel hetzelfde als een struct met uitgebreide mogelijkheden, zoals besproken in de vorige sectie. Het enige verschil is de protectie van de members: • in een struct zijn de declaraties zonder tegenbericht public; • in een class zijn de declaraties zonder tegenbericht private. Het stack-voorbeeld had dus ook als class geschreven kunnen worden: class stack { char info[100]; int top; public: void reset(void) { top = -1; } void push(char c){ top++; info[top]=c; } char top(void) { return info[top]; } };
Denk om het schrijven van de puntkomma aan het eind van de class-declaratie: het blijft een (uitgebreid soort) type-declaratie! Het woord ‘class’ is ontleend aan het object-geori¨enteerde jargon. Variabelen met een type dat als class is gedefinieerd worden objecten genoemd. Een korte karakterisering van object-geori¨enteerd programmeren is: • bij imperatief programmeren staan functies centraal, die objecten als parameter kunnen hebben; 7
• bij objectgeori¨enteerd programmeren staan objecten centraal, die functies als member kunnen hebben. ` Echt object-geori¨enteerd wordt een taal overigens pas als classes geordend kunnen worden in een hi¨erarchie (zie sectie 4.5), en memberfuncties dynamisch gebonden kunnen worden (zie sectie 4.7).
2.4
Definitie van memberfuncties
Tot nu toe definieerden we de memberfuncties direct in de class-declaratie: class c { int x; public: int f(void) { return 2*x; } };
Als de memberfuncties wat langer worden, wordt dit echter erg onoverzichtelijk, omdat je uit het oog kunt verliezen dat al die pagina’s functie-definities in feite deel uitmaken van ´e´en classdeclaratie. Daarom is het ook toegestaan om in de class-declaratie alleen het prototype van de memberfuncties op memberfuncties dynamisch gebonden kunnen worden (zie sectie 4.7), en te nemen: class c { int x; public: int f(void); };
De eigenlijke definitie van de memberfunctie kan daarna apart plaatsvinden. Daarbij moet, als onderscheid met gewone functies, de naam van de class opnieuw genoemd worden: int c::f(void) { return 2*x; }
Meestal wordt de class-declaratie in de .h-file geschreven, en de definities van de memberfuncties in de .cc-file. De class-definitie is immers ook nodig in eventuele andere modules die deze class gebruiken, maar de implementatie van de memberfuncties niet. Een bijkomend verschil tussen memberfunctie-definities in de class-declaratie, en losstaande definities, is dat definities in de class-declaratie per default inline zijn, zoals beschreven in sectie 1.3. Dit is dus alleen maar aan te raden voor zeer korte definities.
2.5
Constructors
Vaak is het nuttig om objecten (dat wil zeggen variabelen waarvan het type een class is) te initialiseren. Hiervoor kan een speciale memberfuncties worden gedefinieerd: een constructor. Deze moet dezelfde naam hebben als de klasse, en heeft geen resultaattype (zelfs niet void). In het voorbeeld van de stack, zou je de top-wijzer bij creatie van een stack willen kunnen initialiseren. Dat kan als volgt: {
char info[100]; int top; public: stack(void) { top = -1; } };
De constructorfunctie wordt automatisch aangeroepen op het moment dat een object wordt gecre¨eerd. Voor globale variabelen is dat v´o´or uitvoer van main, voor lokale variabelen het moment dat de declaratie in het programma ‘uitgevoerd’ wordt, en voor dynamische variabelen bij gebruik van new. Voorbeeld: stack a; main() { print(1);
8
stack b, *p; print(2); p = new stack; }
Eerst wordt hier de constructor van a aangeroepen. Dan wordt in het hoofdprogramma de waarde 1 geprint. Vervolgens wordt de constructor van b aangeroepen. Dan wordt 2 geprint, en tenslotte wordt de constructor van de stack waar p naar wijst aangeroepen. Nu blijkt ook waarom het nuttig is dat declaraties en statements elkaar kunnen afwisselen: aanroep van de constructorfunctie van a vindt pas plaats n´ a dat de waarde 1 geprint is. Constructorfuncties kunnen ook parameters krijgen. Actuele parameters moeten dan meegegeven worden bij declaratie en bij gebruik van new. Voorbeeld: class punt { int x, y; public: punt(int x0, int y0) { }; main() { punt hier(12,5), *p; p = new punt(2,6); }
x=x0; y=y0; }
Let op: in het laatste statement vervult punt dus zowel de rol van type (achter new) als van (constructor)functie (voor zijn parameters). Naast constructorfuncties zijn er ook destructorfuncties. Die worden automatisch aangeroepen aan het eind van de levensduur van een object. Bij globale variabelen is dat na afloop van de functie main, bij lokale variabelen aan het eind van die functie (en vlak voor elke return), en by dynamische variabelen bij gebruik van de delete constructie. Nu is dus ook duidelijk waarom er een aparte delete-constructie nodig is in plaats van de functie free uit C. Een voorbeeld hiervan volgt in sectie 3.1.
3 3.1
Voorbeelden Dynamisch geheugen
Vaak zal er in objecten gebruik gemaakt worden van dynamisch geheugen. Dit geheugen kan worden gealloceerd in de constructorfunctie, en worden opgeruimd in de destructorfunctie. Een voorbeeld is alweer de stack-klasse. In eerdere voorbeelden gebruiken we een array ter lengte 100, nu maken we een dynamische array. Bij de membervariabelen zit er alleen maar een pointer naar de data: class stack { char *info; int top;
In de constructorfunctie laten we de pointer wijzen naar nieuw aangemaakt geheugen. De constructorfunctie heeft een parameter die aangeeft hoe lang de stack maximaal mag worden: public: stack(int n) { info = new char[n]; top = -1; }
In de destructorfunctie wordt het geheugen weer opgeruimd. Net als de constructorfunctie heeft de destructorfunctie geen resultaattype. De naam is die van de class, voorafgegaan door een slangetje: ~stack(void) { delete info;
9
} };
In het hoofdprogramma kunnen we nu stacks van verschillende lengte aanmaken: main() { stack a(100); stack b(1000); }
Bij gebruik van stacks hoef je je nooit meer druk te maken over het opruimen ervan: dat gaat automatisch.
3.2
Open/sluit constructies
Er zijn meer gevallen (dan dynamische geheugenallocatie) waarbij je in C geconfronteerd wordt met ‘vergeet vooral niet aan het eind . . . te doen’. Files bijvoorbeeld moeten aan het begin geopend worden, daarna mag je er van alles mee doen, maar aan het eind moeten ze weer gesloten worden. In een typisch C programma kun je dan ook aantreffen: File f; f = open("aap"); seek(f,pos); read(f,data); close(f);
In een C++-library zou het openen mooi in de constructorfunctie kunnen staan, en het sluiten in de destructorfunctie. Bovendien hoeft de file niet steeds meegegeven te worden bij operaties die op de file werken. Althans niet expliciet. Achter de schermen wordt de file natuurlijk wel meegegeven. { File f("aap"); f.seek(pos); f.read(data); }
3.3
Veilige arrays
Een bekend nadeel van C is dat bij indicering van arrays de grens niet gecontroleerd wordt. Je kunt hier wat aan doen door een klasse te maken waarin array-operaties worden gedefinieerd m`et grens-controle. In dit voorbeeld noemen we deze klasse Vector. De elementen zijn integers. In de constructorfunctie wordt een array gealloceerd, maar bovendien wordt de bovengrens bewaard: class Vector { int *p; int size; public: Vector(int n=10) { size=n; p=new int[n]; } ~Vector(void) { delete p; } int &elem(int); };
Verder is er een memberfunctie elem, waarmee een element uit de array geselecteerd kan worden. Deze functie geeft een foutmelding als de index buiten het toegestane interval ligt. int & Vector::elem(int i) { if (i<0 || i>=size) printf("bound error"); return p[i]; }
De functie elem levert een referentie naar een integer op. Daardoor kan de functie worden gebruikt in expressies, maar ook aan de linkerkant van een assignment.
10
main() { Vector a(10), b(5); a.elem(1) = 17; b.elem(1) = a.elem(1) + 9; }
Helemaal mooi wordt het als we de functie elem als operator defini¨eren, en wel de operator []. int & Vector::operator [](int i) { if (i<0 || i>=size) printf("bound error"); return p[i]; }
Daarna lijken vectoren voor de gebruiker ‘echte’ arrays: main() { Vector a(10), b(5); a[1] = 17; b[1] = a[1] + 9; }
4 4.1
Classes (vervolg) Static members
Het woord static krijgt er in C++ een betekenis bij. In C wordt dit gebruikt voor variabelen die qua scope lokaal zijn voor een functie, maar waarvan slechts ´e´en instantie wordt gemaakt. Een static variabele overleeft dus een functieaanroep, en kan bijvoorbeeld gebruikt worden om te tellen hoe vaak de functie is aangeroepen: void f(void) { static int n=0; printf("ik ben %d keer aangeroepen", n++); }
Voor de implementatie is het alsof de variabele n buiten de functie was gedeclareerd; het enige verschil is dat het niet toegestaan is om de variabele buiten de functie te gebruiken. Op dezelfde manier kunnen in C++ member-variabelen static worden gedeclareerd. Ook nu wordt er slechts ´e´en instantie van die variabele gemaakt, die door alle instanties van de class wordt gedeeld: class c { static int n; int x; int y; public: void f() { n++; } void g() { n++; } void h() { printf ("%d keer memberfuncie gebruikt" , n); } };
Ook dit is eigenlijk een globale variabele, met de restrictie dat hij alleen in de memberfuncties van een bepaalde klasse mag worden gebruikt. Naast membervariabelen kunnen ook memberfuncties static worden gedeclareerd. Static memberfuncties mogen geen gebruik maken van de membervariabelen. Daarom hoeven ze in een implementatie dus geen verborgen parameter mee te krijgen. Het zijn eigenlijk gewone functies, die ook buiten de klasse gedeclareerd hadden kunnen worden. Het enige verschil is dat de functies buiten de klasse niet aangeroepen mogen worden.
11
4.2
Objecten als members
Inmiddels is er een probleempje ontstaan, vanwege twee nieuwe mogelijkheden: constructorfuncties kunnen parameters hebben, en membervariabelen mogen zelf ook objecten zijn. Het probleem is: welke parameter moet meegegeven worden bij constructie van de deel-objecten? Bekijk het voorbeeld van een klasse waarin twee vectoren, zoals gedefinieerd in sectie 3.3, worden gecombineerd: class Twee { Vector heen; Vector terug; public: Twee(int n) {} };
Je kun bij declaratie van de vectoren niet n meegeven, want diens scope is beperkt tot de body van de constructorfunctie Twee. Maar je kunt heen en terug ook niet declareren in de body van de constructorfunctie Twee, want dan zouden ze weer worden opgeruimd aan het eind van de constructorfunctie. De oplossing is een speciale syntax voor dit geval: class Twee { Vector heen; Vector terug; public: Twee(int n) : heen(n), terug(n) {} }
Tussen de header en de body van een constructorfunctie mogen dus de deel-objecten van parameters worden voorzien.
4.3
this
Memberfuncties zijn bedoeld om op objecten te werken zonder dat het object steeds expliciet als parameter meegegeven hoeft te worden (achter de schermen gebeurt dat natuurlijk wel). Maar soms wil je een object ook wel meegeven aan een andere functie dan de memberfuncties van zijn eigen klasse. In dat geval moet je de parameter expliciet noteren. Bekijk bijvoorbeeld een klasse, en een functie die een pointer naar een object uit die klasse meekrijgt als parameter: class klasse; void f(klasse *obj);
Als je in het hoofdprogramma een object declareert, kun je dat object moeiteloos meegeven als parameter: main() { klasse a, *p; f(&a); p = new klasse; f(p); }
Anders wordt het als de functie f aangeroepen moet worden vanuit ´e´en van de memberfuncties van de klasse. Die memberfuncties hebben toegang tot een object van hun klasse, want memberfuncties hebben achter de schermen een extra parameter. Maar hoe moeten ze deze extra parameter aan f doorspelen? Het is immers een extra parameter, die niet expliciet een naam heeft. De oplossing hiervoor is het keyword this dat in C++ beschikbaar is. Memberfuncties kunnen hiermee de pointer naar ‘hun’ object aanduiden. 12
class klasse { int x; public: void g(void); void h(void) { // impliciete parameter gebruikt voor toegang tot andere members print(x); g(); // moet expliciet genoemd om ‘dit’ object // door te geven aan niet-member functies f(this); } };
4.4
Operatoren als members
Omdat memberfuncties impliciet een extra parameter hebben, krijgen operatoren die als member worden gedefinieerd een parameter minder dan je zou verwachten. Een binaire operator wordt gedeclareerd met ´e´en parameter: class Polynoom { Polynoom operator + (Polynoom *y); };
De andere parameter is de impliciete ‘this’ parameter.
4.5
Subklassen
Het leuke van object-geori¨enteerd programmeren is dat je classes eenvoudig kunt uitbreiden met een paar extra members. Je kunt dus voortborduren op werk van anderen, en hoeft voor de nieuwe classes niet opnieuw alle oude members op te sommen. Stel bijvoorbeeld dat er een klasse Persoon is, met allerlei interessante persoonsgegevens, en de nodige memberfuncties: class Persoon { public: char naam[20]; int gebJaar; int leeftijd(void); void print(void); };
Je kunt dan zelf een klasse Student maken, die aan de persoonsgegevens een membervariabele toevoegt voor de studie. Daartoe moet je achter de naam van de klasse specificeren dat het een derived class is van de oorspronkelijke klasse: class Student : public Persoon { public: char studie[10]; void print(void); };
In dit voorbeeld hebben we niet alleen een extra membervariabele toegevoegd, maar ook een memberfunctie. Die heeft toevallig dezelfde naam als een memberfunctie in de oorspronkelijke klasse, maar dat is geen probleem: functies mogen immers overloaded worden. Als je in het programma een variabele van het type Student declareert, dan mag je daarvan de nieuwe members gebruiken (s.studie), maar ook de oude (s.naam). Die laatste worden zogezegd ge¨eerfd van de oorspronkelijke klasse. main() { Student s;
13
... s.naam ... ... s.studie ... s.print(); }
Waar in het hoofdprogramma de functie print wordt aangeroepen, is dat de functie print zoals die in de klasse Student is gespecificeerd.
4.6
Hergedefinieerde memberfuncties
Als tweede voorbeeld schrijven we een klasse die voortborduurt op de klasse Vector uit sectie 3.3. Die luidde: class Vector { int *p, size; public: Vector(int); ~Vector(void) int &elem(int); };
We maken nu een subklasse BndVector voor een array die niet alleen een bovengrens heeft, maar ook een ondergrens (bij de oorspronkelijke vectoren moest die ondergrens 0 zijn). In de nieuwe klasse wordt, naast de ge¨erfde members, een nieuwe variabele toegevoegd: class BndVector : public Vector { int eerste; public:
In de constructorfunctie van BndVector moet de constructorfunctie van Vector worden aangeroepen. Omdat die een parameter heeft, moeten we ons weer van speciale syntax bedienen: BndVector(int lo, int hi) : Vector(hi-lo) { eerste = lo; }
Let op het verschil met sectie 4.2: daar stond achter de dubbele punt de naam van een member, die zelf een object was; nu staat er achter de dubbele punt de naam van de superklasse. Een ander probleem treedt op in de definitie van elem. Hierbij willen we de originele elem aanroepen, echter met een voor de ondergrens gecorrigeerde parameter. Zou je echter in de memberfunctie elem de functie elem aanroepen, dan resulteert dit in een recursieve aanroep. Daarom moeten we de naam elem qualificeren voor de juiste klasse. Dat gebeurt door de naam van de klasse waaruit we de functie willen hebben voor d enaam te schrijven: int &elem(int i) { return Vector::elem(i-eerste); } };
Die klasse moet natuurlijk wel een superklasse zijn van de klasse waarin de aanroep gebeurt, of een superklasse van die superklasse, enz.
4.7
Statische en dynamische binding
Binding van functienamen aan functies gebeurt statisch. Dat wil zeggen dat de compiler, op grond van de beschikbare type-informatie, beslist welke functie gebruikt wordt bij een bepaalde naam. Bekijk bijvoorbeeld een klasse A, en een subklasse B daarvan, die beide een functie f als member hebben: class A { public: int f(void){ return 1; } }; class B : public A { public:
14
int f(void){ return 2; } };
Als in het hoofdprogramma een functie met de naam f wordt aangeroepen, dan kijkt de compiler naar het type van het ontvangende object: main() { A a; B b; a.f(); b.f(); }
// levert 1 // levert 2
Iets lastiger wordt het als we pointers naar objecten gebruiken. Bekijk het volgende programma: main() { A a, *pa; B b; pa = &a; pa->f(); pa = &b; pa->f(); }
// // // //
dit mag levert 1 dit mag ook! wat levert dit?
We declareren een pointer die naar objecten van type A kan wijzen. In het eerste statement laten we de pointer naar a van type A wijzen. Aanroep van de functie f levert dan natuurlijk 1. We mogen de pointer echter ook laten wijzen naar objecten met als type een subklasse van A. Een subklasse is immers een ‘bijzonder’ geval van de klasse, dus een pointer die naar objecten van type A kan wijzen, kan zeker naar objecten van type B wijzen. Dus pa = &b is toegestaan. Maar wat levert nu de aanroep pa->f()? Omdat de binding statisch is, moet de compiler beslissen. En omdat de voorgeschiedenis van de aanroep pa->f() erg ingewikkeld kan zijn, kan de compiler niet in alle gevallen nagaan wat het type is van het object waar pa naar wijst. Zeker is echter, dat dit het type A is of een subtype van A. Veiligheidshalve wordt daarom de functie f van A gebruikt. De aanroep pa->f() levert dus 1, ongeacht het type van het object waar pa toevallig naar wijst. Het is in C++ echter mogelijk om te kiezen voor dynamische binding van functies. Dat moet dan gespecificeerd worden bij de declaratie van de functie in de superklasse, met behulp van het woord virtual. class A { public: virtual int f(void){ return 1; } }; class B : public A { public: int f(void){ return 2; } // type moet hetzelfde zijn als A::f };
Een restrictie is nu dat het type van de in de subklasse opnieuw gedefinieerde functie hetzelfde moet zijn als het origineel. Als we nu weer hetzelfde hoofdprogramma schrijven: main() { A a, *pa; B b; pa = &a; pa->f(); pa = &b; pa->f(); }
// levert 1 // levert nu 2!
Dan wordt run-time nagegaan naar welk type object de pointer wijst. Afhankelijk daarvan wordt de juiste functie f gekozen. De aanroep p->f() levert nu dus 2 op, op het moment dat de pointer naar een object van type B wijst. Voor klassen waarin virtual memberfuncties worden gebruikt, zal dus het type van een object in dat object moeten worden opgeslagen. Dat kan, want bij creatie van een object is het type ervan 15
bekend. In de meeste implementaties gebeurt dit in de vorm van een pointer naar een tabelletje waarin de implementatie van de functies behorend bij deze klasse staan. Run-time kan in dit tabelletje de juiste waarde worden opgezocht. Virtuele functies kosten dus iets meer tijd (een extra indirectie bij de aanroep) en ruimte (´e´en pointer per object). Daar staat tegenover dat ze een groot gemak bieden voor de programmeur: die kan nu immers een pointer laten lopen door een lijst met zowel ‘personen’ als ‘studenten’, voor elke waarde de functie print aanroepen, en toch steeds de goede versie daarvan krijgen.
5 5.1
Input/output Streams
Dankzij de nieuwe taalconstructies die in C++ beschikbaar zijn, konden er nieuwe faciliteiten voor input/output gemaakt worden. Deze zijn gemakkelijker te gebruiken dan printf en dergelijke. De vertrouwde <stdio.h> blijft natuurlijk beschikbaar, maar is eigenlijk overbodig geworden. De nieuwe I/O-bibliotheek heet
. In wordt een klasse stream gedefinieerd. Twee streams die alvast beschikbaar zijn, zijn cin en cout, corresponderend met de standaard-input en standaard-output. Op deze streams zijn de operaties <<, respectievelijk >> gedefinieerd. (Die operatoren bestonden al in C, met de betekenis ‘shift left’ en ‘shift right’; ze zijn nu overloaded, zodat ze ook op streams kunnen werken). Deze operaties werken zo, dat het transport van data in de richting van de pijltjes plaatsvindt: #include main() { int n; cin >> n; // lezen cout << 2*n; // schrijven }
Door middel van overloading zijn deze operatoren gedefinieerd voor alle standaardtypen. Afhankelijk van het type van de rechter parameter krijg je de goede versie. Het is dus niet meer nodig om met "%d" of "%s" en dergelijke het type aan te geven, zoals dat bij printf en scanf nodig was. (Het is ook niet meer mogelijk om daar fouten bij te maken.) Wat betreft het type van de I/O-operatoren: de linker parameter is altijd een stream. De rechter parameter kan van elk standaardtype zijn. In het geval van << is dat een value parameter, maar bij >> is het een reference parameter. Het is dus geen pointer-parameter, zoals dat bij scanf het geval was, en je kunt dus ook bij aanroep de &-operator niet meer vergeten op te schrijven. Als resultaat leveren << en >> hun linker parameter weer op. Dat is handig, want zo kun je meerdere dingen na elkaar lezen of schrijven: cin >> a >> b >> c; cout << "de som is " << a+b+c;
Blijkbaar associ¨eren << en >> naar links. Om een nieuwe regel te schrijven, kun je de string "\n" naar een stream sturen, maar beter is het om de speciale constante endl te gebruiken: cout << "\n"; cout << endl;
// dit mag // dit is beter
Het voordeel van de laatste is dat naast het schrijven van de newline de stream ‘geflushd’ wordt, zodat de uitvoer niet gebufferd wordt. Als lezen niet mogelijk is (bijvoorbeeld omdat het einde van de file bereikt is) levert cin een null-stream op. Daarmee kun je dus eenvoudig testen of het einde van de invoer bereikt is: while (cin >> n) cout << n;
De klasse stream kent een aantal memberfuncties, waarmee extra aanwijzingen over de te gebrui16
ken lay-out van uitvoer gespecificeerd kunnen worden. (Bij printf gebeurde dat in de ‘formatstring’). Zo is er bijvoorbeeld de memberfunctie width, waarmee het aantal te gebruiken posities gespecificeerd wordt, en precision waarmee de precisie van uit te voeren floating-point getallen wordt aangegeven: cout.width(10); cout.precision(7); cout << pi;
Verder is er een memberfunctie get, waarmee ´e´en character gelezen kan worden. Deze is nodig omdat << alvorens een karakter te lezen spaties en newlines overslaat. Een kopieer-programma is dus: #include main() { char c; while (cin.get(c)) cout << c; }
5.2
Files
In feite is er niet ´e´en klasse stream. Deze klasse heeft twee subklassen: istream en ostream. Memberfuncties die alleen relevant zijn voor outputstreams zijn gedefinieerd in ostream. Deze klassen hebben op hun beurt weer subklassen voor streams die gekoppeld zijn aan een file: ifstream respectievelijk ofstream. (De naam ifstream is een afkorting van ‘input file stream’ en heeft dus niets met if-statements te maken.) De constructorfunctie van deze streams heeft een filenaam als parameter. Daarmee is het mechanisme uit sectie 3.2 gerealiseerd: #include main() { ofstream f("aap"); f << "deze tekst wordt in een file gezet" << endl; }
De file hoeft niet expliciet gesloten te worden: dat gebeurt in de destructorfunctie.
6
Slot
6.1
Andere constructies
In dit korte bestek konden niet alle details van C++ behandeld worden. Een aantal dingen die niet genoemd zijn, en die je ‘in het wild’ kunt tegenkomen zijn: • Access control. Naast public en private is er ook nog protected: members die alleen toegankelijk zijn voor subklassen. • Friends. Bepaalde klassen en/of functies kunnen aangewezen worden als ‘friend’, die t`och gebruik mogen maken van de private members. • Multiple inheritance. Klassen kunnen gelijktijdig subklasse zijn van meerdere klassen. De overervings-hi¨erarchie is dus niet een boomstructuur, maar een gerichte graaf. • Templates. Klassen kunnen worden geparametriseerd met een type, zodat polymorfe datastructuren kunnen worden gedefinieerd. • Container classes. In de praktijk kan het nuttig zijn om enkele libraries te kennen waarin een aantaal veelgebruikte datastructuren als klasse beschikbaar zijn. Vooral container classes, waarin dingen als lijsten en verzamelingen zijn ge¨ımplementeerd, zijn populair. Voor dit 17
soort klassen worden vaak speciale iterator classes gedefinieerd, waarmee ze gemakkelijk langsgelopen kunnen worden. Op objecten van zo’n iterator class is typisch de operator ++ gedefinieerd, zodat het langslopen van bijvoorbeeld een lijst erg gaat lijken op het langslopen van een array. Waar je op moet letten bij container classes is of bij destructie van de containers ook de objecten die daar in zitten worden opgeruimd of juist niet.
6.2
Andere talen
Veel van de in deze tekst genoemde onderwerpen, in het bijzonder de classes, kom je ook tegen bij het bestuderen van andere object-geori¨enteerde talen. Deze talen kunnen afwijken van C++ op grond van de keuzen die erin gemaakt zijn. Bijvoorbeeld: • Classes en typen. In sommige talen zijn er geen ‘gewone’ typen meer, maar is alles een class. Ale functies zijn dan ook memberfuncties. • Binding van memberfuncties. In C++ is de binding van memberfuncties alleen bij virtual members dynamisch. In sommige talen is de binding altijd dynamisch. • Type van her-definities. In C++ moet het type van her-definities van virtual functies in subklassen precies hetzelfde zijn als in de oorspronkelijke klasse. Deze eis is in sommige talen minder streng. In een taal kan de keuze vallen op contravariante herdefinities of covariante herdefinities, elk met hun eigen problematiek.
Literatuur • Stroustrup, Bjarne. Addison-Wesley, 1991.
The C++ programming Language, second edition.
Reading:
• Ellis, Margaret and Bjarne Stroustrup. The annotated C++ reference manual. Reading: Addison-Wesley, 1994.
18
