I N H O U D S T A B E L. 1. Uitbreidingen en verbeteringen in C++ t.o.v. C... 8

Transcriptie

1 1 I N H O U D S T A B E L 1. Uitbreidingen en verbeteringen in C++ t.o.v. C Inleiding Het gebruik van de iostream bibliotheek In- en uitvoer De iostream bibliotheek Algemeen Het begrip stream De verschillende streamklassen Uitvoer Invoer I/O manipulatoren Opmaak van getallen Algemene opmaak Uitlijnen Het plaatsen van de declaraties van variabelen Typeconversie Converteren Typedef Het type const Het const type Expressies Het type referentie Probleem Het type referentie Het referentie datatype Programmavoorbeeld Initialisatie van een referentie Referentie als functieparameter Verschil tussen pointer en referentie Referenties als terugkeerwaarde Initialisatie van variabelen Overloaded functies Overloading Gebruik Functie aanroepen met argumenten van verschillend type Voorbeeld met automatische convertie Voorbeeld met verlies van data Type-safe linken Probleem Type-safe linken Inline functies Inline specifier en inline functie Functie versus macro Vraag aan de compiler Default functie-argumenten Default functie-argumenten Voorbeeld... 30

2 Default argumenten en functie-overloading Wat kan met functie-overloading en default argumenten? New en delete Dynamische geheugenallocatie De-allocatie van geheugen Dynamische array Overloaden van de new operator Gebruik van de set_new_handler Namespaces Het concept namespaces van C Gebruik van variabelen Commentaar Oefeningen Klassen en objecten Creatie van een nieuw datatype in C Het datatype klasse Programma-voorbeeld 1 en bespreking Programma-voorbeeld 2 en bespreking Definitie van een klasse en OOP Definitie van een klasse OOP OOP versus procedureel programmeren De principes van OOP Opbouw van een klasse Toegangscontrole tot klasseleden Constructoren en destructor Constructor Default constructor Constructor met argumenten Constructor overloading Constructor met default argumenten Constructor overloading en default argumenten Probleem en oplossing Programma voorbeeld Destructor Object als argument van een lidfunctie Constante objecten en constante lidfuncties Constante objecten Constante lidfuncties Objecten als functiewaarde Object als referentie argument Oefeningen Conversie, klassen en operatoren Algemeen De copy constructor Algemeen Programmavoorbeeld Default copy constructor Constructoren en conversie De conversie constructor Conversie door een constructor met default argumenten T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

3 Voorwaardelijke compilatie Conversie na de initialisatie Conversie met andere constructoren Overzicht en samenvatting constructoren Operator overloading Algemeen Lidfunctie die de som berekent van twee objecten Tijdelijk object door een constructor laten maken De operator + in plaats van de somfunctie Operatoren voor overloading De this-pointer De this-pointer Overladen van een assignment-operator Friend operatoren Friend Probleem De friend operator Conversie van een klasse naar een standaardtype De conversie-functie Impliciete en expliciete aanroep van een conversie-functie Conversie tussen klassen Oefeningen Overerving Overerving (E: inheritance) Basisklasse en afgeleide klasse Doelstellingen van overerving De basisklasse Afgeleide klasse Constructie van een afgeleide klasse Geheugenlayout van een afgeleid object Programmavoorbeeld Private, public en protected Default-constructor van de basisklasse Eigen constructor van een afgeleide klasse Initializer Functie-overriding Functie-overriding Programma met overriding van de print-functie Functie overriding versus functie overloading Overridden functie aanroepen vanuit de afgeleide klasse Toegangsregels Algemeen Toegangsregels van een privaat afgeleide klasse Toegangsregels voor een publiek afgeleide klasse Voorbeeld Overzichtstabel Data hiding Invloed van overerving op de bescherming van leden van een klasse Een is een relatie Beschermende interface via een afgeleide klasse Meer dan één afgeleide klasse

4 Schematische voorstelling Waar komt wat? Programmavoorbeeld Constructoren en afgeleide klassen Afgeleide klasse van een afgeleide klasse Schematische voorstelling Programmavoorbeeld Meervoudige overerving (multiple inheritance) Algemeenheden Programmavoorbeeld Ambiguïteit bij meervoudige overerving Virtuele basisklasse Probleem Programma met tweemaal indirectie overerving van dezelfde klasse Oplossing met behulp van een virtuele basisklasse Programma Virtuele basisklasse Schematische voorstelling Templates Definitie Voorbeeld Generieke typen Functietemplate versus preprocessor-macro Voorbeeld met preprocessor-macro Met een functietemplate Werking van de functietemplate Klassetemplates Gebruik Programmavoorbeeld Oefeningen Polymorfisme en virtuele lidfuncties Virtuele lidfunctie Het keyword virtual Probleem Voorbeeld van probleemgeval Virtuele lidfunctie Dynamische binding (late binding) Dynamische binding Late binding versus vroege binding Polymorfisme Woordverklaring Gebruik van het concept polymorfisme Polymorfisme in C Voorbeeld Programmavoorbeeld Abstracte basisklasse Doel en gebruik van een abstracte klasse Nut van een abstracte klasse Definitie van een abstracte klasse Programmavoorbeeld De I/O bibliotheek van C T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

5 5 6.1 De isostream bibliotheek Het begrip stream De verschillende streamklassen Hiërachie Soorten streams Het vereenvoudigd model van iostream De ostreamklasse De istreamklasse De ofstreamklasse De klasse ofstream Een nieuw bestand maken Strings schrijven naar een bestand De ifstreamklasse De klasse ifstream Een bestand lezen met behulp van een stream Strings lezen uit een bestand Inlezen van strings met de extraction-operator Probleem met de extraction-operator Strings lezen uit een bestand met getline() Het testen van een stream Mogelijk optredende fouten Het testen met de naam van de stream De lidfunctie fail() Functies die fouten behandelen De strstreamklasse De lidfuncties str() en freeze() De manipulator setw en de lidfunctie width() De manipulator setiosflags Links uitlijnen Rechts uitlijnen Een vast aantal cijfers na het decimale punt Wetenschappelijke notatie Aanvullen van een veld Talstelsels decimaal, hexadecimaal en octaal De manipulator endl De manipulator flush Input/Output met objecten I/O van objecten met behulp van lidfuncties I/O van objecten met behulp van operatoren Opzet Voorbeeld Objecten in een bestand Algemeen Schrijven van objecten naar een bestand Lezen van objecten uit een bestand Tegelijk objecten lezen uit en schrijven in een bestand Random file access Algemeen Beschikbare inputstream functies Beschikbare outputstream lidfuncties Tweede argument van seekg() en seekp()

6 Allerlei met bestanden Een stream na de declaratie koppelen aan een bestand Een bestand sluiten Toevoegen aan einde bestand Bestaand bestand openen en leeg maken Werken met een bestaand bestand Niet werken met een bestaand bestand Binaire bestanden Binair bestand versus tekstbestand Schrijven van een object naar een binair bestand Lezen van een object uit een binair bestand Lezen en schrijven van objecten via lidfuncties Bijwerken van een bestand met gebruik van random access Kopiëren van een bestand Kopiëren van een bestand, byte per byte Kopiëren van een bestand met rdbuf() Kopiëren van een bestand naar het beeldscherm Kopiëren van een bestand naar de printer Oefeningen Classes De MFC-bibliotheek Algemeen Groepen klassen De CObject-klasse De CObject-klasse Basiseigenschappen van de CObject-klasse De CFile-klasse Files De CFile-klasse Afgeleide klassen van CFile Voorbeeld Serializatie van objecten Serializatie van een object Een klasse serializeerbaar maken Het serializeren van een object De CException-klasse Exceptions Werking van exception handling Exception handling met verschillende types Definiëren van een exceptie in een klasse Exception-klasse met informatie Het exception mechanisme Teruggooien van een reeds opgevangen exceptie Re-throw Voorbeeld Het voorkomen van geheugenlekken bij excepties Geheugenlekken De catch all instructie Containers Containerklasse Wat is een containerklasse? T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

7 Voorbeeld van containerklasse Containerklasse versus afgeleide klasse STL-bibliotheek Algemeen Inleiding tot het gebruik van de STL-bibliotheek Lidfuncties van een container De Vector container De List container Klassen voor algemeen gebruik De CTime-klasse De CString-klasse Voorbeeld Object georiënteerd ontwerp Systeem van onderling handelende objecten Object georiënteerd ontwerp versus procedureel ontwerp Stappen in een object georiënteerde aanpak Identificatie van de klassen Hiërarchie van de klassen Interface van de klassen Programmatie van de klassen Schrijven van het hoofdprogramma Constructie van correcte klassen Voordelen van het aanwenden van OOP Een op data gerichte aanpak Data abstractie Encapsulatie Inheritance Polymorfisme en dynamische binding Besluit

8 8 1. Uitbreidingen en verbeteringen in C++ t.o.v. C 1.1 Inleiding Het succes van C++ als programmeertaal is voor een groot stuk te wijten aan de opkomst van GUI systemen (Graphical User Interface), zoals bv. Windows. Het programmeren in een GUI-systeem vraagt de manipulatie van velerlei objecten, zoals vensters, menu s, knoppen, enz. Bovendien is een GUI event driven. Dit betekent dat een bepaald object slechts geactiveerd wordt als er een bericht naar toe gestuurd wordt, zoals bv. een muisklik. Dit zijn allemaal aspecten die in object georiënteerd programmeren aan bod komen. Zodoende zal een OOP-taal, zoals C++, praktisch noodzakelijk zijn in dergelijke omgevingen. Bovendien worden de besturingsystemen qua opbouw meer en meer object georiënteerd. Zo is Windows NT een typisch object georiënteerd systeem, waarin alle elementen van het besturingsysteem als objecten worden gehandeld, nl. de user-interface, de disk-interface en netwerk-interface. Een interessant aspect van de C++ taal is het feit dat ze volledig gebaseerd is op de C-taal. C++ laat toe om object georiënteerd te programmeren zonder de opgedane ervaring in het programmeren in C te verlaten. In dit deel willen we de verschillende uitbreidingen en verberingen van C++ aanhalen t.o.v. C, die niet rechtstreeks te maken hebben met de filosofie van object georiënteerd programmeren. Deze uitbreidingen en verbeteringen zijn dikwijls wel wenselijk om het toevoegen van object georiënteerde principes mogelijk te maken. We kunnen zeggen dat deze uitbreidingen de noodzakelijke steunpilaren zijn waarop de C++ taal rust. Tevens zijn vele verbeteringen aangebracht om het programmeren veiliger en meer bugvrij te maken. 1.2 Het gebruik van de iostream bibliotheek In- en uitvoer C++ kent een totaal nieuwe manier van werken met in- en uitvoer. Hiervoor zijn ook nieuwe headerfiles beschikbaar. De vertrouwde C-functies blijven evenwel beschikbaar, doch het mengen van beide moet worden afgeraden. De standaard in- en uitvoer bibliotheek van C++ is de iostream bibliotheek De iostream bibliotheek Algemeen De iostream bibliotheek is de input/output bibliotheek die standaard bijgeleverd is met de C++ compiler. Deze bibliotheek maakt input en output naar het scherm, naar files en naar geheugen mogelijk. De iostream bibliotheek vervangt de stdio bibliotheek van C. T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

9 9 De iostream bibliotheek is niet ingebouwd in de C++ taal zelf, maar vormt een aparte klassen-bibliotheek. Het voordeel van de iostream bibliotheek is het feit dat ze gebruik maakt van alle C++ eigenschappen. Dit betekent dat we input en output operaties kunnen laten verlopen via operatoren. Bovendien kunnen we, indien noodzakelijk, de functionaliteit van de iostream bibliotheek aan onze eigen wensen aanpassen door gebruik te maken van afgeleide klassen Het begrip stream We kunnen een stream beschouwen als een equivalent van een input/output device. Als dusdanig representeert een stream altijd een medium, waarnaar we input/output operaties uitvoeren. In C++ is een stream een object, behorend tot een specifieke streamklasse. De karakteristieken van het stream-object worden bepaald door de klasse waartoe het behoort, en door de eigen toevoegingen aan deze klasse De verschillende streamklassen Er zijn zes belangrijke streamklassen: istream klasse die input verzorgt afkomstig van het toetsenbord ostream klasse die output verzorgt naar het scherm ifstream klasse die input verzorgt afkomstig van files ofstream klasse die output verzorgt naar files istrstream klasse die intput verzorgt afkomstig van het geheugen ostrstream klasse die output verzorgt naar het geheugen Daarbij is er nog de iostream klasse, die afgeleid is uit de klassen istream en ostream Uitvoer De standaard outputstream noemt cout. Gegevens naar de output sturen gebeurt met de insertion operator <<. Voorbeeldprogramma. /* programma P110.cpp */ #include <iostream.h> char c= A ; float f= 12.57; cout << Hello, world.\n ; cout << c = << c << \n ; cout << f = << f << \n ; Dit kleine programma bevat de twee belangrijkste bouwstenen van de C++ taal: het object en de operator. Het object is cout, dat de standaard output representeert. De standaard output is het beeldscherm. Met andere woorden, cout representeert het beeldscherm.

10 10 De operator is <<, die gebruikt wordt om gegevens naar de standaard output te sturen. Merk op dat in tegenstelling tot de functie printf() het in C++ niet nodig is om te specificeren dat een string, of een integer, of een karakter of een float moet worden uitgeprint op het scherm. De uitvoering van de operator << verschilt naargelang de operator inwerkt op een string, of op een integer, of op een karakter of op een float Invoer De standaard inputstream noemt cin. De standaard input is het toetsenbord. Met andere woorde, cin representeert het toetsenbord. Gegevens lezen van de input gebeurt met de extraction operator >>. Voorbeeldprogramma. /* programma P111.cpp */ #include <iostream.h> char c; float f; char sr[30]; cout << Typ een letter in: \n ; cin >> c; cout << Typ een gebroken getal in: \n ; cin >> f; cout << Typ een string in: \n ; cin >> s; cout<< De ingevoerde letter is << c <<endl; cout<< Het ingevoerde getal is << f <<endl; cout<< De ingevoerde string is << s <<endl; Ook bij cin moet het type van de in te voeren variabele niet worden meegegeven I/O manipulatoren Opmaak van getallen Met de manipulatoren dec, hex en oct kan een getal worden weergegeven in respectievelijk decimaal, octaal en hexadecimaal formaat. De functie setbase(int n) bepaalt het talstelsel voor de weergave van het eerst volgende getal. De waarde van n bepaalt het talstelsel: n= 0 (default) : 10-tallig stelsel n= 8 : 8-tallig stelsel n= 10 : 10-tallig stelsel n= 16 : 16-tallig stelsel T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

11 11 De functie setprecision(int n) bepaalt het aantal decimalen bij floating point getallen. /* programma P112.cpp */ #include <iostream.h> #include <iomanip.h> int i; i= 16; cout << dec << i << endl; // 16 cout << oct << i << endl; // 20 cout << hex << i << endl; // 10 cout << setbase(16) << 16 << \t << 16 << endl; // cout << setprecision(4) << << endl; // Algemene opmaak endl setw(int n) setfill(int n) vervangt \n dient om de breedte van een veld op te geven dient om het opvulkarakter aan te geven bij gebruik van setw() /* programma P113.cpp */ #include <iostream.h> #include <iomanip.h> cout << Hello world << endl; cout << setw(8) << setfill( # ) << 45 << endl; Uitlijnen Volgend programma lijnt de eerste uit te printen kolom links uit en de tweede kolom wordt rechts uitgelijnd. /* programma P114.cpp */ #include <iostream.h> #include <iomanip.h> double waarden[] = 1.36, 45.14, 8.124, char *namen[] = Els, Jef, Ria, Jan ; for (int i= 0; i < 4; i++) cout << setiosflags(ios::left) << setw(6) << namen[i] << resetiosflags(ios::right) << setw(10) << waarden[i] << endl;

12 Het plaatsen van de declaraties van variabelen In C kan een declaratie van een variabele slechts gebeuren aan het begin van een blok. Een blok is hier de verzameling code binnen de accolades. In C++ is het mogelijk een declaratie te schrijven gelijk waar in een blok. Een variabele moet dus niet vooraan in een blok gedeclareerd worden. De variabele is gekend van de regel van declaratie tot het einde van de scope. Voor een lokale variabele is dat tot het einde van het blok. Voor een globale variabele is dat tot het einde van het programma. Zo is het volgende toegelaten: double ds1 = sin(1.0); ds1 *= 2; double ds2 = cos(1.0); ds2 *= 2; Deze eigenschap wordt veel gebruikt in for-loops: for (int i= 0; i < 10; i++) // code Echter is een declaratie niet toegelaten in een stuk code dat slechts conditioneel kan uitgevoerd worden: if (x < 10) int y = 20; //fout else int y = 10; //fout Voorbeeld van scope: main() // x is niet gekend // i is niet gekend // j is niet gekend int x; // x is gekend // i is niet gekend // j is niet gekend T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

13 13 for (int i= 0; i < 32767; i++) // x is gekend // i is gekend // j is niet gekend int j; // x is gekend // i is gekend // j is gekend // x is gekend // i is niet gekend // j is niet gekend 1.4 Typeconversie Converteren In C++ plaatst men de te converteren expressie tussen haakjes, zodat dit lijkt op een functie-oproep. De conversie waarbij het type tussen haakjes staat, blijft ook bruikbaar. int i; char c; i = (int) c; // C notatie i = int (c); // C++ notatie Typedef In C zijn er twee manieren om met een struct te werken. 1) struct a ; ; struct a var1; // dit vraagt veel typwerk bij gebruik van struct 2) typedef struct struct_a ; a; a var1; // dit vraagt minder typwerk bij gebruik van struct, maar de // definitie is zwaar In C++ kan het keyword struct weggelaten worden bij de definitie van variabelen van een bepaald type struct. struct a ; ; a var1; // dit vraagt het minst typwerk

14 Het type const Het const type Met het type const wordt een variabele gedeclareerd waarvan de waarde constant moet blijven gedurende de hele uitvoering van het programma. De compiler waakt erover dat zo n variabele geen nieuwe waarde toegekend wordt. In plaats van #define MAXITEMS 10 kan in C++ het volgende: const int MAXITEMS 10; Het voordeel van de nieuwe schrijfwijze t.o.v. de oude is het feit dat het type, in het voorbeeld int, expliciet geverifieerd wordt telkens de variabele wordt gebruikt. const int GROOTTE 30; GROOTTE = 40; // compiler genereert een fout Expressies De expressie const int *pci; declareert een pointer die verwijst naar een const int. Dit betekent dat aan pci wel vrij een adres kan worden toegekend, maar pci verwijst telkens naar een niet te veranderen waarde. Dus: const int d = 3; pci = &d; // OK *pci = 3; // FOUT In volgend programmavoorbeeld wordt de pointer p gedeclareerd naar een const int. Dit betekent dat aan de variabele p wel vrij een adres kan worden toegekend, doch dat p telkens wijst naar een niet te veranderen waarde. /* programma P115.cpp */ #include <iostream.h> const int a= 5, b= 10; const int *p= &a; cout<< Inhoud van p: << (void *)p << endl; cout<< p wijst aan : << *p << endl; p= &b; // ander vrij adres cout<< Inhoud van p: << (void *)p << endl; cout<< p wijst aan : << *p << endl; T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

15 15 De expressie int i; int *const cpi = &i; declareert de constante pointer cpi naar een integer. Deze pointer cpi kan naar niets anders wijzen, maar hetgeen de pointer cpi aanwijst kan wel veranderd worden. Volgend programma declareert een constante pointer p naar een int. De pointer p kan naar niets anders wijzen, maar hetgeen p aanwijst kan wel worden gewijzigd. Dit is een belangrijk verschil met de definitie van p in vorig programma. /* programma P116.cpp */ #include <iostream.h> int a= 5, b= 10; int *const p= &a; cout<< Inhoud van p: << (void *)p << endl; cout<< p wijst aan : << *p << endl; a= 10; // p wijst andere waarde aan cout<< Inhoud van p: << (void *)p << endl; cout<< p wijst aan : << *p << endl; Men kan const ook gebruiken bij het declareren van een functie om te beletten dat de functie één van zijn parameters zou wijzigen. Veronderstel het volgende prototype: int readonly(const struct Astruct *AreadonlyStruct); Dit prototype belet dat de structuur waarnaar AreadonlyStruct verwijst gewijzigd kan worden. Wil de programmeur dit toch doen, dan genereert de compiler een fout, zoals in volgend voorbeeld: int readonly(const struct Astruct *AreadonlyStruct) AreadonlyStruct -> element = 3; //compiler genereert fout 1.6 Het type referentie Probleem Het volgend programma illustreert een probleem dat kan voorkomen bij het toekennen van een waarde aan de parameters van een functie op basis van doorgeven van waarde (call by value). Telkens de functie opgeroepen wordt, worden de waarden van de doorgegeven parameters gekopieerd in de lokale parameters van de functie. Het resultaat hiervan is dat, wanneer een doorgegeven parameter wordt gewijzigd, we die wijziging niet terugzien in de aanroepende functie.

16 16 /* programma P117.cpp */ #include <iostream.h> void increment(int); int i= 3; cout<< i = << i << endl; // i = 3 increment(i); cout<< i = << i << endl; // i = 3 void increment(int i) i++; Het programma geeft als resultaat 3, alhoewel increment(i) de variabele i lokaal heeft gewijzigd in 4. Wanneer de programmeur wenst dat een functie een aantal parameters moet wijzigen, dan moet de programmeur een pointer doorgeven naar die functie (call by address), zoals getoond in volgend programma. /* programma P118.cpp */ #include <iostream.h> void increment(int *); int i= 3; cout<< i = << i << endl; // i = 3 increment(&i); cout<< i = << i << endl; // i = 4 void increment(int* pi) (*pi)++; // () zijn nodig omdat ++ voorrang heeft op * Het vervelende aan bovenstaande constructie is dat expliciet een pointer moet worden doorgegeven aan de functie met behulp van de adres van operator &, en dat telkens de dereferentie operator * moet worden aangewend binnen de functie om bewerkingen te kunnen uitvoeren met de waarden waarnaar de pointer verwijst. T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

17 Het type referentie Het referentie datatype C++ lost vorig probleem op met het referentie datatype. Eens gedeclareerd zal een referentie fungeren als een alias (een alternatieve naam). Met andere woorden, een referentie gedraagt zich precies zoals de variabele waarnaar hij refereert. Een referentie-variabele is dus een alias voor de variabele waarnaar hij refereert, m.a.w. een referentie is een alternatieve naam voor een variabele. Bewerkingen op een referentie refereren altijd naar de gerefereerde variabele. De unaire & operator indentificeert een referentie. Referenties (E: references) worden het meest gebruikt als parameter. Het voordeel is dat geen data getransfereerd wordt zoals bij call by value, en dat het veiliger is dan een call by address. Referenties kunnen worden gebruikt om meer dan één waarde uit een functie terug te geven, waar in C pointers voor nodig zijn Programmavoorbeeld Volgend programma maakt gebruik van een referentie. /* programma P119.cpp */ #include <iostream.h> int i, *pi; int &ri = i; // ri is een referentie naar i, geen &i nodig i = 5; // gebruik van i via zijn naam cout<< waarde van i via zijn naam: << i << endl; cout<< adres van i: <<&i << endl; ri = 10; // gebruik van i via zijn referentie cout<< waarde van i via zijn referentie: << i << endl; // i= 10 int j= ri; // j krijgt de waarde van i, nl. j= 10 cout<< waarde van j: << j << endl; ri++; cout<< waarde van i: << i << endl; // i= 11 pi = &ri; // pi bevat het adres van i cout<< inhoud van pi: << pi << endl; In dit programma is ri een alias voor i. Het maakt geen verschil uit of we i of ri gebruiken bij bewerkingen. Echter is een referentie geen kopie van de variabele waarnaar hij verwijst. Het is wel dezelfde variabele onder een andere naam Initialisatie van een referentie Een referentie kan niet bestaan zonder een variabele waarnaar gerefereerd wordt. Volgende code kan dus niet: int &refint; // fout

18 18 De uitzondering op de regel is wanneer bijvoorbeeld een referentie wordt gedefinieerd als parameter van een functie. Met andere woorden, een reference moet steeds geïnitialiseerd worden bij declaratie, behalve als de referentie als parameter wordt gebruikt. In het volgend programma wordt geen return gebruikt. Merk op dat geen return nodig is om i en ri een nieuwe waarde te geven. /* programma P120.cpp */ #include <iostream.h> void increment(int &); int i= 3; //int &ri; //fout: ri : references must be initialized int &ri= i; // declaratie van de referentie ri cout<< i = << i << endl; // i = 3 cout<< ri = << ri << endl; // ri = 3 increment(ri); // referentie wordt doorgegeven cout<< i = << i << endl; // i = 4, nieuwe waarde uit increment() cout<< ri = << ri << endl; //ri = 4, nieuwe waarde uit increment() //cout<< ra= << ra << endl; //fout: ra :undeclared identifier void increment(int &ra) // declaratie van ra zonder initialisatie ra++; cout<< ra= << ra << endl; // ra= Referentie als functieparameter Het referentie datatype is vooral interessant bij het doorgeven van te veranderen parameters naar een procedure. /* programma P121.cpp */ #include <iostream.h> void increment(int &); int i= 3; int &ri= i; // declaratie van de referentie ri cout<< i = << i << endl; // i = 3 cout<< ri = << ri << endl; // ri = 3 increment(ri); // referentie wordt doorgegeven cout<< i = << i << endl; // i = 4 cout<< ri = << ri << endl; // ri = 4 void increment(int &ri) ri++; T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

19 Verschil tussen pointer en referentie Een referentie is eigenlijk niets anders dan een constante pointer, die we kunnen gebruiken zonder dereferentie operator. Zo kan vorig programma P120 geschreven worden met een constante pointer. /* programma P122.cpp */ #include <iostream.h> int i= 3; int *const ri= &i; // ri is een constante pointer naar i cout<< i = << i << endl; // i= 3 cout<< ri = << ri << endl; // adres van de geheugenplaats van ri cout<< *ri = << *ri << endl; // 3 increment(ri); // pointer ri wordt doorgegeven cout<< i = << i << endl; // i= 4 cout<< ri = << ri << endl; // adres van de geheugenplaats van ri cout<< *ri = << *ri << endl; // 4 void increment(int *ri) *ri++; Bemerk echter dat een referentie niet kan behandeld worden als een pointer. Een aantal zaken zijn niet mogelijk met een referentie, terwijl die wel mogelijk zijn met een pointer. 1) Het adres nemen van een referentie kan. /* programma P123.cpp */ #include <iostream.h> int i= 3; int &ri= i; // declaratie van de referentie ri cout<< ri = << ri << endl; // ri = 3 cout<< adres van ri= << &ri << endl; int *pi; pi= π // het adres van pi wordt toegekend aan pi cout<< adres van ri= << pi << endl; (*pi)++; cout<< i = << i << endl; cout<< ri = << ri << endl;

20 20 2) Een referentie toekennen met een waarde kan niet. /* programma P124.cpp */ #include <iostream.h> int i= 3; //int &ri= 5; // een referentie toekennen met een waarde // fout: initializing : cannot convert from const int to int & int &ri = i; cout<< ri = << ri << endl; // ri= 3 ri= 5; // dit kan wel cout<< i = << i << endl; // i= 5 cout<< ri = << ri << endl; // ri= 5 3) Twee referenties vergelijken met elkaar kan. /* programma P125.cpp */ #include <iostream.h> int i1= 3, i2= 5; int &ri1= i1; int &ri2= i2; if (ri1 == ri2) cout<< gelijk <<endl; else cout<< ongelijk <<endl; cout<<endl; if (ri1 > ri2) cout<< ri1 <<endl; else cout<< ri2 <<endl; 4) Twee referenties optellen kan. /* programma P126.cpp */ #include <iostream.h> int i1= 3, i2= 5; int &ri1= i1; int &ri2= i2; cout<< ri1 + ri2 = << ri1+ri2 << endl; T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

21 21 5) Enkel een referentie aan een constant object kan geïnitialiseerd worden met een rvalue of met een lvalue van een ander type. /* programma P127.cpp */ #include <iostream.h> int i= 1; double dl1= 2.3, dl2= 10.5; // int &ri= 5; // fout: initializing : cannot convert from // const int to int &, m.a.w. geen lvalue // double &rdl1= i; // fout: initializing : cannot convert from // int to double &, m.a.w. 2 verschillende types // double &rdl= dl1 + dl2; // fout: geen lvalue const int &ri= 5; // initialisatie met een rvalue cout<< ri= << ri << endl; // ri= 5 const double &rdl1= i; // initialisatie met een lvalue van een ander type cout<< rdl1= << rdl1 << endl; // rdl1= 1 const double &rdl= dl1 + dl2; // toegelaten cout<< rdl= << dl1 + dl2<< endl; // rdl= ) Een referentie wijzigen kan niet. /* programma P128.cpp */ #include <iostream.h> int i1= 3, i2= 5; int &ri1= i1; //int &ri1= i2; //fout: ri1 : redefinition; multiple initialization cout<< ri1 = << ri1 << endl; 7) Het is mogelijk een referentie (in het voorbeeld de referentie r1), die de formele parameter is van een functie (in het voorbeeld van de functie f1), opnieuw door te geven als actuele parameter (in het voorbeeld de actuele parameter r1 van de functie f2(r1) naar een functie waar de formele parameter opnieuw een referentie is (in het voorbeeld naar de functie f2(int &r2) waar de formele parameter r2 een referentie is). /* programma P129.cpp */ #include <iostream.h> void f2(int &r2) r2*=2;

22 22 void f1(int &r1) f2(r1); int i= 7; f1(i); cout<< i = << i << endl; // i= Referenties als terugkeerwaarde Naast het doorgeven van parameters naar een functie, kunnen referenties ook gebruikt worden voor het teruggeven van waarden door een functie. In het volgende programma geeft de functie num() een referentie terug aan EenNummer. We kunnen zeggen dat num() als een alias fungeert voor EenNummer. Met andere woorden, we krijgen hetzelfde resultaat als in main() de functie num() vervangen wordt door EenNummer. /* programma P130.cpp */ #include <iostream.h> int EenNummer= 0; int &num() return EenNummer; int i; i= num(); num() = 5; Functies die een referentie terug geven kunnen als lvalue gebruikt worden, zoals getoond in volgend programma. De functie min(i1, i2) wordt als lvalue gebruikt in min(i1, i2) = min(i1, i2) * 3. Concreet wordt de opdracht: i1= 10 * 3. /* programma P131.cpp */ #include <iostream.h> int &min(int &ri1, int &ri2) return(ri1 < ri2? ri1 : ri2); // ri1 refereert naar i1, waardoor i1 blijft // bestaan als de functie is afgelopen T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

23 23 int i1= 10, i2= 20; min(i1, i2)*= 3; //het kleinste getal wordt vermenigvuldigd met 3 cout<< i1= << i1 << endl; // i1= 30 cout<< i2= << i2 << endl; // i1= Initialisatie van variabelen Initialisatie is het initieel toekennen van een waarde van een variabele. De variabele krijgt een beginwaarde. Initialiseren gebeurt telkens bij het declareren van de variabele. De syntax voor de initialisatie van een variabele is gevoelig verbeterd in C++ tenopzichte van C. 1) Een eerste verbetering is de mogelijkheid om een variabele te intitialiseren met behulp van een volledige expressie in plaats van met een constante expressie, zoals getoond in volgende code: const double pi = acos(-1.0); const double e = exp(1.0); 2) Een andere verbetering t.o.v. C is de mogelijkheid om de initialisatie te schrijven met behulp van haakjes. Volgende C-code int i = 0; double x = 1.0; kan in C++ als volgt: int i(0); double x(1.0); Deze schrijfwijze is vooral nuttig wanneer men klassen wil initialiseren via hun constructor, zoals Complex c(1.0, 2.0); evenals: Complex c = Complex(1.0, 2.0); 3) Een volgende verbetering is de specificatie van een cast. Waar in C een cast wordt gespecificeerd door volgende code: int i; double d; d = (double) i; kan die in C++ vervangen worden door: int i; double d; d = double( i);

24 Overloaded functies Overloading Een veel voorkomend geval is dat de programmeur functies schrijft die hetzelfde uitvoeren, maar die een verschillend aantal argumenten of een verschillend type argumenten aanvaarden. In C is het noodzakelijk om deze functies een verschillende naam toe te kennen. Zo zal volgende notatie noodzakelijk zijn: Complex_i(int x, int y); Complex_d(double x, double y); Complex_c(struct complex c); In C++ is het echter toegelaten hiervoor dezelfde functie-namen te gebruiken. Dit is overloading van functies. Voorwaarde is wel dat de functies onderscheiden kunnen worden door een verschillend aantal argumenten, of door een verschillend type van argumenten. Het vorig voorbeeld kan dus herschreven worden als: Complex(int x, int y); Complex (double x, double y); Complex (struct complex c); Bij een aanroep van Complex() zal de compiler die versie van Complex() oproepen die dezelfde types van parameters heeft als de aanroep. Complex(3, 4); // roept Complex(int x, int y) op Complex(4.2, 6.5); // roept Complex(double x, double y) op Wanneer er geen exacte overeenkomst van parameters is, dan gelden de standaard conversie-regels voor het vinden van een overeenstemmende routine. Soms levert dit dubbelzinnige situaties op, zoals in volgend voorbeeld: Complex((long) 3, (long) 4); // fout De compiler geeft de fout: ambiguous call to overloaded function, omdat zowel Complex(double x, double y) als Complex(int x, int y) kan worden gebruikt. Dit levert een ambigue (dubbelzinnige, tweeslachtige) situatie op. De compiler weet niet wat gedaan. In C++ zijn twee functies verschillend als hun namen verschillen of als hun aantal parameters verschillen, of als de types in een andere volgorde staan. Dit betekent dat de functie abx(int) en de functie abs(float) twee verschillende functies zijn. Het returntype is niet van belang om te bepalen of een functie-declaratie reeds voorkomt. Bijgevolg zijn int random(void) en float random(void) dezelfde functies en dit levert een compiler-fout op. T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

25 Gebruik Overloading kan het programmeren aanzienlijk vereenvoudigen, zoals getoond in volgend programma. /* programma P132.cpp */ #include <iostream.h> int square(int r) return ( r >= -250 && r <= 250)? r*r : -1; long square(long r) return ( r >= && r <= 40263)? r*r : -1; void main(void) int i= 20; long lg= 1064; cout<< i kwadraat = <<square(i)<<endl; cout<< lg kwadraat = <<square(lg)<<endl; Functie aanroepen met argumenten van verschillend type Voorbeeld met automatische convertie /* programma P132.cpp */ #include <iostream.h> void demo(double); void main(void) demo(10); demo(5.24); //automatische conversie van int naar double void demo(double a) cout<< a << is een double. << endl; Resultaat: 10 is een double is een double.

26 Voorbeeld met verlies van data /* programma P133.cpp */ #include <iostream.h> void demo(int); void main(void) demo(10); demo(5.24); //warning: argument :conversion from const double to int //possible loss of data void demo(int a) cout<< a << is een int. << endl; Resultaat: 10 is een int. 5 is een int. // verlies van data 1.9 Type-safe linken Probleem Alhoewel men in C++ verplicht is om een prototype mee te geven bij het aanroepen van een functie, bestaan er toch situaties waarbij de compiler niet kan garanderen dat de correcte argumenten worden doorgegeven aan de aangeroepen functie. Veronderstel bijvoorbeeld dat een bibliotheekfunctie wordt aangeroepen en dat het prototype, meegegeven in het programma, andere types argumenten specificeert dan de bibliotheekfunctie verwacht. Doordat de compiler geen weet heeft van de juiste structuur van de bibliotheekfunctie, zal verkeerde code worden gegenereerd. Bovendien rijst het probleem van overloaded functies. Immers, overloaded functies hebben dezelfde functienaam, maar een verschillend type argumenten. De oplossing voor die problemen is het aanwenden van een type-safe linken procedure Type-safe linken Type-safe linken is een systeem dat garandeert dat functies gelabeld worden met informatie betreffende de argument-types, zodat bij het linken de correcte functies worden aangeroepen. Concreet betekent dit dat de compiler de naam van de functie intern zal omvormen tot een nieuwe naam, die de informatie bevat betreffende het type argumenten. Bij het linken wordt dan die interne naam gebruikt om de functie in kweste te koppelen aan de functie die in de bibliotheek voorkomt. Wanneer dan de programmeur een fout maakt in het specificeren van het prototype, zal tijdens het linken een fout T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

27 27 worden gegenereerd, die zegt dat de bedoelde functie met dit type van argumenten niet kan teruggevonden worden in de bibliotheek. Type-safe linken garandeert echter niet dat de functie-terugkeertypes correct zijn, of dat extern gerefereerde variabelen van de correcte types zijn. Voorbeeld: #include<math.h> double afstand(double x1, double y1, double x2, double y2) double d1 =x2 x1; double d2 = y2 y1; In een andere file wordt de functie afstand() op de volgende manier opgeroepen: #include<stdio.h> extern int afstand(double, double, double, double); prinft( %d\n, afstand(1.0, 1.0, 2.0, 2.0); De code in de main() zal nonsens teruggeven omdat het prototype voor afstand() liegt betreffende het returntype. De compiler kan de fout niet ontdekken omdat de functie extern gedeclareerd wordt. Ook zal de linker geen fout geven omdat het type-safe linken niet in staat is om het returntype te verifiëren. Het probleem ligt bij het extern declareren van functies en/of variabelen direct in functies. Externe declaraties horen thuis in header files en niet rechtstreeks in de source files Inline functies Inline specifier en inline functie Een inline functie is een functie die begint met de inline specifier, zoals bijvoorbeeld: inline MAX(int getal1, int getal2). De inline specifier wordt ook inline specificator genoemd. Het sleutelwoord (E: keyword) inline kenmerkt de functie voor inline expansie, nl. een inline functie wordt op de plaats van de aanroep door de compiler tot de functie-body geëxpandeerd Functie versus macro Een groot nadeel van een functie is dat ze traag werkt. Immers, bij gebruik van de functie MAX(int getal1, int getal2) moeten de twee argumenten worden gekopieerd, moeten machineregisters worden opgeslagen en moet het programma op een nieuwe locatie instructies selecteren. In plaats van de functie grootste = MAX(10, 50) op te roepen, is de handmatige code grootste = (a > b)? a : b; gewoon sneller.

28 28 Een macro wordt wel in de code gevoegd. Een macro werkt dus als de handmatige code, maar bij gebruik van een macro worden de argumenten vervangen door hun waarde, en dit kan leiden tot fouten. Volgend programma bepaalt het grootste van twee getallen met behulp van een macro. Waar in C veel gebruik wordt gemaakt van macro s om korte functies rechtstreeks als code in te voegen in de source file, dit om een expliciete aanroep van een functie te vermijden en dus de snelheid van uitvoering op te drijven, geeft dit soms aanleiding tot problemen, zoals in volgend voorbeeld. /* programma P134.cpp */ #include <iostream.h> #define MAX(getal1, getal2)((getal1>getal2)?getal1:getal2) //macro int grootste; grootste = MAX(10, 50); cout<< Grootste getal is << grootste << endl; // 50 cout<<endl; int getal2 = 50; grootste = MAX(10, getal2++); cout<< Grootste getal is << grootste << endl; // 51 In het tweede geval is de waarde van grootste niet juist (het moet 50 zijn). Dit komt omdat de code als volgt werd geëxpandeerd: grootste= ((10 > 51)? 10 : 51) Om functies te expanderen tot gewone code in een programma en dit op een veilige manier, laat C++ toe inline functies te gebruiken, zoals in volgend programma. /* programma P135.cpp */ #include <iostream.h> inline MAX(int, int); //prototype van de inline functie int grootste; grootste = MAX(10, 50); cout<< Grootste getal is << grootste << endl; // 50 cout<<endl; int getal2 = 50; grootste = MAX(10, getal2++); cout<< Grootste getal is << grootste << endl; // 50 inline MAX(int getal1, int getal2) // inline functie return (getal1 > getal2)? getal1 : getal2; T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

29 29 Het stukje code grootste = MAX(10, getal2++) wordt nu geëxpandeerd tot: int temp1= 10; int temp2 = getal2++; grootste = temp1 > temp2? temp1 : temp2; Bij int temp2 = getal2++; wordt eerst de inhoud van getal2 toegekend aan temp2 en pas daarna wordt de inhoud van getal2 met 1 verhoogd Vraag aan de compiler De inline specifier expandeert niet altijd een functie. De inline specifier fungeert alleen als een hint voor de compiler. De compiler kan kiezen om de functie niet te expanderen, afhankelijk van het nut, bv. wanneer de inline functie te veel regels code bevat zodat het nut ervan teniet gedaan wordt, of in bepaalde omstandigheden waarin de compiler niet kan expanderen. Een inline functie wordt niet geëxpandeerd als die recursief gedefinieerd is, of wanneer een pointer naar de functie genomen wordt. In het volgende voorbeeld zal de eerste aanroep van MAX() geëxpandeerd worden, de tweede niet. int (*p) (int a, int b); int x = MAX(3, 5); //MAX wordt geëxpandeerd p= MAX; // p krijgt het adres van de functie MAX() int y = p(3, 5); //MAX() wordt niet geëxpandeerd omdat de //pointer p naar MAX() is opgenomen in het //programma 1.11 Default functie-argumenten Default functie-argumenten Default functie-argumenten betekent dat een functie een default waarde heeft voor argumenten, die niet expliciet geïnitialiseerd worden. Volgende functiedefinitie bevat een default waarde voor de argumenten x2 en y2, die niet expliciet in main() zijn geïnitialiseerd: double distance(double x1, double y1, double x2= 0, double y2= 0) De default argumenten moeten op het einde van de functiedefinitie worden geplaatst. C++ voorziet de mogelijkheid om bij de aanroep van een functie minder argumenten mee te geven dan het aantal parameters bedraagt. In dat geval moeten in de functiedefinitie de default waarden van die argumenten zijn

30 30 opgenomen. De default argumenten worden gebruikt bij een functieoproep als de daarop volgende argumenten ontbreken. Naast de directe specificatie van de default argumenten in de functiedefinitie is het ook mogelijk om de default argumenten te specificeren in het functieprototype, maar dan moet de functiedefinitie zonder default argumenten worden genoteerd Voorbeeld In volgend programma wordt de afstand berekend tussen twee punten. Indien de coördinaten van het tweede punt niet worden meegegeven naar de functie, wordt de afstand berekend t.o.v. het nulpunt. /* programma P136.cpp */ #include <iostream.h> #include <math.h> double afstand(double x1, double y1, double x2= 0, double y2= 0) double d1= x2 x1; double d2 = y2 y1; return sqrt(d1*d1 + d2*d2); //sqrt()= square root (vierkantswortel) // en vereist math.h double afstand1 = afstand(2, 8); //x1=2, y1=8, x2=0, y2=0 cout<< afstand1= << afstand1 << endl; //afstand1= double afstand2 = afstand(5,9,2,5); //x1=5, y1=9, x2=2, y2=5 cout<< afstand2= << afstand2 << endl; //afstand2= 5 Wanneer een waarde wordt meegegeven voor x2 en y2, dan worden die waarden gebruikt, anders worden x2 en y2 geïntialiseerd op 0. In het opgegeven programma moet minstens twee argumenten worden meegegeven aan de functie. De default waarden moeten altijd op het einde worden geplaatst Default argumenten en functie-overloading Volgend programma toont hoe bij de oproep van de functie lijn(), de default argumenten worden aangewend wanneer in de oproepende code de daaropvolgende argumenten ontbreken. Bij lijn() ontbreken de twee argumenten. De eerste default argumentwaarde is het karakter - voor het argument c, en de tweede default argumentwaarde is de waarde 80 voor het argument i. Bij lijn( = ) ontbreekt het tweede argument, dat de default waarde 80 krijgt. Merk op dat de argumentwaarde van de oproepende code de bovenhand haalt op de default argumentwaarde. Bij lijn( =, 20) krijgen de twee argumenten een waarde van de oproepende code. T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc

31 31 Bij lijn(30) treedt er een fout op omdat de doorgegeven argumentwaarde, nl. de getalwaarde 30, niet kan worden toegekend aan het argument char c. /* programma P137.cpp */ #include <iostream.h> void lijn(char c= -, int i= 80) for (int t= 1; t<=i; t++) cout<< c; cout<< endl; lijn(); // afdruk van 80 keer het karakter - lijn( = ); // afdruk van 80 keer het karakter = lijn( =, 20); // afdruk van 20 keer het karakter = lijn(30); // levert foutief resultaat op Met functie-overloading van de functie lijn() met een functie die een integer aanvaardt als parameter, is het foutief resultaat van vorig programma ongedaan gemaakt, en worden alle combinaties mogelijk. /* programma P138.cpp */ #include <iostream.h> void lijn(char c= -, int i= 80) for (int t= 1; t<=i; t++) cout<< c; cout<< endl; void lijn(int i) for (int t= 1; t<=i; t++) cout<< # ; cout<< endl; lijn(); // afdruk van 80 keer het karakter - lijn( = ); // afdruk van 80 keer het karakter = lijn( =, 20); // afdruk van 20 keer het karakter = lijn(30); // afdruk van 30 keer het karakter #

32 Wat kan met functie-overloading en default argumenten? Stel de functie: lijn(char c= -, int i= 80), dan: -> lijn(void) geeft ambiguiteit bij de oproep lijn(), omdat de eerste functie niet kan worden overloaded met een functie met als argument void. -> lijn(char c) geeft ambiguiteit bij de oproep lijn( = ), omdat van de eerste functie en van de tweede functie het argument zonder default waarde, nl. char c, van hetzelfde type zijn en in dezelfde volgorde staan. Daardoor kan de eerste functie niet worden overloaden met de functie lijn(char c). -> lijn(int a) is OK. -> lijn(int a= 70) geeft abiguiteit bij de oproep lijn(), omdat het eerste argument van de eerste en van de tweede functie niet overeenkomen. -> lijn(char c, long lg= 50000) geeft ambiguiteit bij de oproep lijn( = ), omdat het tweede argument van de tweede functie een default waarde heeft. -> lijn(char c, int i) geeft ambiguiteit bij de oproep lijn( =, 70), omdat van beide functies de argumenten zonder default waarde van hetzelfde type zijn en in dezelfde volgorde staan. -> lijn (int i, char c) is OK, omdat van beide functies de argumenten niet in dezelfde volgorde staan. -> lijn(int i, int i) is Ok, omdat de compiler geen conversie doet en dus wel onderscheid kan maken. Wanneer de functies lijn(int, int) en lijn(long, long) worden opgeroepen met twee char s, dan zal de functie lijn(int, int) worden uitgevoerd omdat er een automatische conversie gebeurt naar het grotere type. Gezien het default argument geen deel uitmaakt van de functie, heeft dit volgende consequentie: de defintie void (*p1)(char, int) = &lijn // is OK doch de definitie void (*p1)(char) = &lijn // kan niet omdat het type niet overeen stemt New en delete Dynamische geheugenallocatie In C++ wordt uitgebreid gebruik gemaakt van dynamische geheugenallocatie, noodzakelijk bij het alloceren van objecten die een levensduur hebben die langer is dan de procedure waarin ze aangemaakt zijn. Om het alloceren van objecten (het dynamisch toekennen van geheugen voor objecten) gemakkelijker te maken, is in T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\ Programmeren in C++.doc