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

1

INHOUDSTABEL 1. Uitbreidingen en verbeteringen in C++ t.o.v. C................................ 8 1.1

Inleiding..........................................................................................8

1.2

Het gebruik van de iostream bibliotheek ..............................................8

1.2.1

In- en uitvoer ............................................................................8

1.2.2

De iostream bibliotheek ...............................................................8

1.2.2.1

Algemeen...............................................................................8

1.2.2.2

Het begrip stream ...................................................................9

1.2.2.3

De verschillende streamklassen .................................................9

1.2.3

Uitvoer .....................................................................................9

1.2.4

Invoer .................................................................................... 10

1.2.5

I/O manipulatoren .................................................................... 10

1.2.5.1

Opmaak van getallen ............................................................. 10

1.2.5.2

Algemene opmaak ................................................................. 11

1.2.5.3

Uitlijnen ............................................................................... 11

1.3

Het plaatsen van de declaraties van variabelen ................................... 12

1.4

Typeconversie ................................................................................ 13

1.4.1

Converteren ............................................................................ 13

1.4.2 1.5

Typedef .................................................................................. 13 Het type const ............................................................................... 14

1.5.1

Het const type ......................................................................... 14

1.5.2 1.6

Expressies ............................................................................... 14 Het type referentie ......................................................................... 15

1.6.1

Probleem................................................................................. 15

1.6.2

Het type referentie ................................................................... 17

1.6.2.1

Het referentie datatype .......................................................... 17

1.6.2.2

Programmavoorbeeld ............................................................. 17

1.6.3

Initialisatie van een referentie .................................................... 17

1.6.4

Referentie als functieparameter .................................................. 18

1.6.5

Verschil tussen pointer en referentie ........................................... 19

1.6.6

Referenties als terugkeerwaarde ................................................. 22

1.7

Initialisatie van variabelen ............................................................... 23

1.8

Overloaded functies ........................................................................ 24

1.8.1

Overloading ............................................................................. 24

1.8.2

Gebruik................................................................................... 25

1.8.3

Functie aanroepen met argumenten van verschillend type .............. 25

1.8.3.1

Voorbeeld met automatische convertie ..................................... 25

1.8.3.2

Voorbeeld met verlies van data ............................................... 26

1.9 1.9.1 1.9.2 1.10

Type-safe linken ............................................................................. 26 Probleem................................................................................. 26 Type-safe linken....................................................................... 26 Inline functies ................................................................................ 27

1.10.1

Inline specifier en inline functie .................................................. 27

1.10.2

Functie versus macro ................................................................ 27

1.10.3 1.11

Vraag aan de compiler .............................................................. 29 Default functie-argumenten ............................................................. 29

1.11.1

Default functie-argumenten ....................................................... 29

1.11.2

Voorbeeld................................................................................ 30

2

1.11.3

Default argumenten en functie-overloading .................................. 30

1.11.4

Wat kan met functie-overloading en default argumenten? .............. 32

1.12

New en delete ................................................................................ 32

1.12.1

Dynamische geheugenallocatie ................................................... 32

1.12.2

De-allocatie van geheugen......................................................... 33

1.12.3

Dynamische array..................................................................... 33

1.12.4

Overloaden van de new operator ................................................ 34

1.12.5 1.13

Gebruik van de set_new_handler ................................................ 35 Namespaces .................................................................................. 36

1.13.1

Het concept ‘namespaces’ van C++ ............................................ 36

1.13.2

Gebruik van variabelen.............................................................. 36

1.14

Commentaar.................................................................................. 37

1.15

Oefeningen .................................................................................... 37

2. Klassen en objecten................................................................... 38 2.1

Creatie van een nieuw datatype in C++ ............................................. 38

2.1.1

Het datatype klasse .................................................................. 38

2.1.2

Programma-voorbeeld 1 en bespreking........................................ 39

2.1.3

Programma-voorbeeld 2 en bespreking........................................ 41

2.2

Definitie van een klasse en OOP........................................................ 43

2.2.1

Definitie van een klasse............................................................. 43

2.2.2

OOP ....................................................................................... 44

2.2.2.1

OOP versus procedureel programmeren .................................... 44

2.2.2.2

De principes van OOP............................................................. 44

2.3

Opbouw van een klasse ................................................................... 45

2.4

Toegangscontrole tot klasseleden...................................................... 46

2.5

Constructoren en destructor............................................................. 48

2.5.1

Constructor ............................................................................. 48

2.5.2

Default constructor ................................................................... 50

2.5.3

Constructor met argumenten ..................................................... 51

2.5.4

Constructor overloading ............................................................ 52

2.5.5

Constructor met default argumenten ........................................... 53

2.5.6

Constructor overloading en default argumenten ............................ 54

2.5.6.1 2.5.6.2 2.5.7

Probleem en oplossing ........................................................... 54 Programma voorbeeld ............................................................ 54 Destructor ............................................................................... 55

2.6

Object als argument van een lidfunctie .............................................. 57

2.7

Constante objecten en constante lidfuncties ....................................... 59

2.7.1

Constante objecten ................................................................... 59

2.7.2

Constante lidfuncties................................................................. 59

2.8

Objecten als functiewaarde .............................................................. 60

2.9

Object als referentie argument ......................................................... 62

2.10

Oefeningen .................................................................................... 64

3. Conversie, klassen en operatoren ................................................ 64 3.1

Algemeen ...................................................................................... 64

3.2

De copy constructor ........................................................................ 65

3.2.1

Algemeen ................................................................................ 65

3.2.2

Programmavoorbeeld ................................................................ 66

3.2.3

Default copy constructor............................................................ 67

3.3

Constructoren en conversie .............................................................. 68

3.3.1

De conversie constructor ........................................................... 68

3.3.2

Conversie door een constructor met default argumenten ................ 69

T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

3

3.3.3

Voorwaardelijke compilatie ........................................................ 71

3.3.4

Conversie na de initialisatie........................................................ 71

3.3.5

Conversie met andere constructoren ........................................... 74

3.4

Overzicht en samenvatting constructoren........................................... 74

3.5

Operator overloading ...................................................................... 75

3.5.1

Algemeen ................................................................................ 75

3.5.2

Lidfunctie die de som berekent van twee objecten ......................... 75

3.5.3

Tijdelijk object door een constructor laten maken.......................... 77

3.5.4

De operator + in plaats van de somfunctie ................................... 78

3.5.5

Operatoren voor overloading ...................................................... 79

3.5.6

De this-pointer......................................................................... 80

3.5.6.1

De this-pointer...................................................................... 80

3.5.6.2

Overladen van een assignment-operator ................................... 81

3.6 3.6.1

Friend operatoren ........................................................................... 82 Friend ..................................................................................... 82

3.6.2

Probleem................................................................................. 82

3.6.3

De friend operator .................................................................... 83

3.7 3.7.1 3.7.2

Conversie van een klasse naar een standaardtype ............................... 85 De conversie-functie ................................................................. 85 Impliciete en expliciete aanroep van een conversie-functie ............. 86

3.8

Conversie tussen klassen ................................................................. 87

3.9

Oefeningen .................................................................................... 89

4. Overerving ............................................................................... 90 4.1 4.1.1 4.1.2

Overerving (E: inheritance).............................................................. 90 Basisklasse en afgeleide klasse................................................... 90 Doelstellingen van overerving..................................................... 90

4.2

De basisklasse ............................................................................... 91

4.3

Afgeleide klasse ............................................................................. 92

4.3.1

Constructie van een afgeleide klasse ........................................... 92

4.3.2

Geheugenlayout van een afgeleid object ...................................... 92

4.3.3

Programmavoorbeeld ................................................................ 93

4.3.4

Private, public en protected........................................................ 94

4.3.5

Default-constructor van de basisklasse ........................................ 94

4.3.6

Eigen constructor van een afgeleide klasse................................... 95

4.3.7

Initializer................................................................................. 95

4.4

Functie-overriding .......................................................................... 96

4.4.1

Functie-overriding .................................................................... 96

4.4.2

Programma met overriding van de print-functie ............................ 97

4.4.3

Functie overriding versus functie overloading................................ 99

4.4.4

Overridden functie aanroepen vanuit de afgeleide klasse .............. 100

4.5 4.5.1

Toegangsregels ............................................................................ 100 Algemeen .............................................................................. 100

4.5.2

Toegangsregels van een privaat afgeleide klasse......................... 101

4.5.3

Toegangsregels voor een publiek afgeleide klasse ....................... 101

4.5.4

Voorbeeld.............................................................................. 102

4.5.5

Overzichtstabel ...................................................................... 103

4.5.6

Data hiding............................................................................ 103

4.5.7

Invloed van overerving op de bescherming van leden van een klasse103

4.5.8

Een ‘is een’ – relatie ............................................................... 104

4.5.9 4.6

Beschermende interface via een afgeleide klasse......................... 104 Meer dan één afgeleide klasse ........................................................ 106

4

4.6.1

Schematische voorstelling........................................................ 106

4.6.2

Waar komt wat? ..................................................................... 107

4.6.3

Programmavoorbeeld .............................................................. 107

4.6.4 4.7

Constructoren en afgeleide klassen ........................................... 109 Afgeleide klasse van een afgeleide klasse ......................................... 110

4.7.1

Schematische voorstelling........................................................ 110

4.7.2


4.8

Meervoudige overerving (multiple inheritance).................................. 113

4.8.1

Algemeenheden ..................................................................... 113

4.8.2


4.8.3 4.9

Ambiguïteit bij meervoudige overerving ..................................... 115 Virtuele basisklasse ...................................................................... 117

4.9.1

Probleem............................................................................... 117

4.9.2

Programma met tweemaal indirectie overerving van dezelfde klasse117

4.9.3

Oplossing met behulp van een virtuele basisklasse ...................... 119

4.9.3.1

Programma ........................................................................ 119

4.9.3.2

Virtuele basisklasse ............................................................. 120

4.9.3.3

Schematische voorstelling..................................................... 120

4.10

Templates ................................................................................... 121

4.10.1

Definitie ................................................................................ 121

4.10.2

Voorbeeld.............................................................................. 122

4.10.3

Generieke typen ..................................................................... 122

4.10.4

Functietemplate versus preprocessor-macro ............................... 123

4.10.4.1 4.10.4.2

Voorbeeld met preprocessor-macro ....................................... 123 Met een functietemplate ...................................................... 123

4.10.5

Werking van de functietemplate................................................ 124

4.10.6

Klassetemplates ..................................................................... 125

4.10.6.1

Gebruik............................................................................. 125

4.10.6.2

Programmavoorbeeld .......................................................... 125

4.11

Oefeningen .................................................................................. 127

5. Polymorfisme en virtuele lidfuncties ............................................128 5.1

Virtuele lidfunctie ......................................................................... 128

5.1.1

Het keyword ‘virtual’ ............................................................... 128

5.1.2

Probleem............................................................................... 128

5.1.3

Voorbeeld van probleemgeval................................................... 128

5.1.4 5.2

Virtuele lidfunctie ................................................................... 131 Dynamische binding (late binding) .................................................. 131

5.2.1

Dynamische binding................................................................ 131

5.2.2

Late binding versus vroege binding ........................................... 132

5.3

Polymorfisme ............................................................................... 132

5.3.1

Woordverklaring..................................................................... 132

5.3.2

Gebruik van het concept polymorfisme ...................................... 132

5.3.3

Polymorfisme in C++ .............................................................. 132

5.3.4

Voorbeeld.............................................................................. 133

5.3.5 5.4 5.4.1

Programmavoorbeeld .............................................................. 134 Abstracte basisklasse .................................................................... 136 Doel en gebruik van een abstracte klasse................................... 136

5.4.2

Nut van een abstracte klasse.................................................... 136

5.4.3

Definitie van een abstracte klasse ............................................. 136

5.4.4


6. De I/O – bibliotheek van C++ ....................................................140 T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

5

6.1

De isostream – bibliotheek............................................................. 140

6.2

Het begrip stream......................................................................... 140

6.3

De verschillende streamklassen ...................................................... 141

6.3.1

Hiërachie............................................................................... 141

6.3.2

Soorten streams..................................................................... 141

6.3.3

Het vereenvoudigd model van iostream .................................... 141

6.4

De ostreamklasse ......................................................................... 142

6.5

De istreamklasse .......................................................................... 143

6.6

De ofstreamklasse ........................................................................ 143

6.6.1

De klasse ofstream ................................................................. 143

6.6.2

Een nieuw bestand maken ....................................................... 144

6.6.3

Strings schrijven naar een bestand ........................................... 145

6.7

De ifstreamklasse ......................................................................... 146

6.7.1

De klasse ifstream .................................................................. 146

6.7.2

Een bestand lezen met behulp van een stream ........................... 146

6.7.3

Strings lezen uit een bestand ................................................... 147

6.7.3.1

Inlezen van strings met de extraction-operator ........................ 147

6.7.3.2

Probleem met de extraction-operator ..................................... 147

6.7.3.3

Strings lezen uit een bestand met getline() ............................. 148

6.7.4

Het testen van een stream....................................................... 148

6.7.4.1

Mogelijk optredende fouten................................................... 148

6.7.4.2

Het testen met de naam van de stream .................................. 148

6.7.4.3

De lidfunctie fail()................................................................ 149

6.7.4.4

Functies die fouten behandelen ............................................. 149

6.8

De strstreamklasse ....................................................................... 150

6.8.1

De lidfuncties str() en freeze().................................................. 150

6.8.2

De manipulator setw en de lidfunctie width() .............................. 150

6.8.3

De manipulator setiosflags ....................................................... 151

6.8.3.1

Links uitlijnen ..................................................................... 151

6.8.3.2

Rechts uitlijnen ................................................................... 152

6.8.3.3

Een vast aantal cijfers na het decimale punt ............................ 152

6.8.3.4

Wetenschappelijke notatie .................................................... 153

6.8.3.5

Aanvullen van een veld ........................................................ 153

6.8.3.6

Talstelsels decimaal, hexadecimaal en octaal ........................... 154

6.8.3.7

De manipulator endl ............................................................ 154

6.8.3.8

De manipulator flush............................................................ 155

6.9

Input/Output met objecten ............................................................ 155

6.9.1

I/O van objecten met behulp van lidfuncties ............................... 155

6.9.2

I/O van objecten met behulp van operatoren.............................. 156

6.9.2.1

Opzet ................................................................................ 156

6.9.2.2

Voorbeeld........................................................................... 156

6.9.3 6.9.3.1

Objecten in een bestand .......................................................... 159 Algemeen........................................................................... 159

6.9.3.2

Schrijven van objecten naar een bestand ................................ 159

6.9.3.3

Lezen van objecten uit een bestand ....................................... 160

6.9.3.4 6.9.4

Tegelijk objecten lezen uit en schrijven in een bestand ............. 161 Random file access ................................................................. 162

6.9.4.1

Algemeen........................................................................... 162

6.9.4.2

Beschikbare inputstream functies........................................... 162

6.9.4.3

Beschikbare outputstream lidfuncties ..................................... 162

6.9.4.4

Tweede argument van seekg() en seekp()............................... 163

6

6.10

Allerlei met bestanden................................................................... 163

6.10.1

Een stream na de declaratie koppelen aan een bestand................ 163

6.10.2

Een bestand sluiten ................................................................ 163

6.10.3

Toevoegen aan einde bestand .................................................. 164

6.10.4

Bestaand bestand openen en leeg maken................................... 164

6.10.5

Werken met een bestaand bestand ........................................... 164

6.10.6

Niet werken met een bestaand bestand ..................................... 165

6.11

Binaire bestanden......................................................................... 165

6.11.1

Binair bestand versus tekstbestand ........................................... 165

6.11.2

Schrijven van een object naar een binair bestand........................ 165

6.11.3

Lezen van een object uit een binair bestand ............................... 167

6.11.4

Lezen en schrijven van objecten via lidfuncties ........................... 168

6.11.5 6.12

Bijwerken van een bestand met gebruik van random access ......... 170 Kopiëren van een bestand.............................................................. 171

6.12.1

Kopiëren van een bestand, byte per byte. .................................. 171

6.12.2

Kopiëren van een bestand met rdbuf()....................................... 172

6.12.3

Kopiëren van een bestand naar het beeldscherm......................... 172

6.12.4 6.13

Kopiëren van een bestand naar de printer .................................. 173 Oefeningen .................................................................................. 173

7. Classes ...................................................................................174 7.1

De MFC-bibliotheek....................................................................... 174

7.1.1

Algemeen .............................................................................. 174

7.1.2

Groepen klassen..................................................................... 174

7.2

De CObject-klasse ........................................................................ 175

7.2.1

De CObject-klasse .................................................................. 175

7.2.2 7.3

Basiseigenschappen van de CObject-klasse ................................ 175 De CFile-klasse ............................................................................ 175

7.3.1

Files ..................................................................................... 175

7.3.1.1

De CFile-klasse ................................................................... 175

7.3.1.2

Afgeleide klassen van CFile ................................................... 175

7.3.1.3 7.3.2

Voorbeeld........................................................................... 176 Serializatie van objecten.......................................................... 177

7.3.2.1

Serializatie van een object .................................................... 177

7.3.2.2

Een klasse serializeerbaar maken........................................... 177

7.3.2.3

Het serializeren van een object.............................................. 179

7.4

De CException-klasse .................................................................... 181

7.4.1

Exceptions............................................................................. 181

7.4.2

Werking van exception handling ............................................... 182

7.4.3

Exception handling met verschillende types ................................ 183

7.4.4

Definiëren van een exceptie in een klasse .................................. 185

7.4.5

Exception-klasse met informatie ............................................... 186

7.4.6

Het exception mechanisme ...................................................... 187

7.4.7

Teruggooien van een reeds opgevangen exceptie ........................ 189

7.4.7.1 7.4.7.2 7.4.8

Re-throw............................................................................ 189 Voorbeeld........................................................................... 190 Het voorkomen van geheugenlekken bij excepties ....................... 191

7.4.8.1

Geheugenlekken.................................................................. 191

7.4.8.2

De ‘catch all’ instructie ......................................................... 191

7.5

Containers................................................................................... 192

7.5.1 7.5.1.1

Containerklasse...................................................................... 192 Wat is een containerklasse? .................................................. 192


7

7.5.1.2

Voorbeeld van containerklasse .............................................. 192

7.5.1.3

Containerklasse versus afgeleide klasse .................................. 193

7.5.2

STL-bibliotheek ...................................................................... 194

7.5.2.1

Algemeen........................................................................... 194

7.5.2.2

Inleiding tot het gebruik van de STL-bibliotheek....................... 195

7.5.2.3

Lidfuncties van een container ................................................ 198

7.5.2.4

De Vector container ............................................................. 198

7.5.2.5

De List container ................................................................. 199

7.6 7.6.1

Klassen voor algemeen gebruik ...................................................... 200 De CTime-klasse .................................................................... 200

7.6.2

De CString-klasse ................................................................... 200

7.6.3

Voorbeeld.............................................................................. 201

8. Object georiënteerd ontwerp ......................................................202 8.1

Systeem van onderling handelende objecten .................................... 202

8.2

Object georiënteerd ontwerp versus procedureel ontwerp ................... 203

8.3

Stappen in een object georiënteerde aanpak .................................... 203

8.3.1

Identificatie van de klassen...................................................... 204

8.3.2

Hiërarchie van de klassen ........................................................ 204

8.3.3

Interface van de klassen.......................................................... 204

8.3.4

Programmatie van de klassen................................................... 205

8.3.5

Schrijven van het hoofdprogramma........................................... 205

8.4

Constructie van correcte klassen..................................................... 205

8.5

Voordelen van het aanwenden van OOP ........................................... 206

8.6

Een op data gerichte aanpak .......................................................... 207

8.6.1

Data abstractie ...................................................................... 207

8.6.2

Encapsulatie .......................................................................... 208

8.6.3

Inheritance............................................................................ 208

8.6.4

Polymorfisme en dynamische binding ........................................ 209

8.6.5

Besluit .................................................................................. 209

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 1.2.1 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.

1.2.2 De iostream bibliotheek 1.2.2.1 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.


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.

1.2.2.2 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.

1.2.2.3 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.

1.2.3

Uitvoer De standaard outputstream noemt cout. Gegevens naar de output sturen gebeurt met de insertion operator <<. Voorbeeldprogramma. /* programma P110.cpp */ #include void main() { 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

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.

1.2.4 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 void main() { 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.

1.2.5

I/O manipulatoren

1.2.5.1 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


11

De functie setprecision(int n) bepaalt het aantal decimalen bij floating point getallen. /* programma P112.cpp */ #include #include void main() { 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;

// 10

cout << setprecision(4) << 3.1415926535 << endl;

// 3.1415

16

}

1.2.5.2 Algemene opmaak endl

vervangt “\n”

setw(int n)

dient om de breedte van een veld op te geven

setfill(int n)

dient om het opvulkarakter aan te geven bij gebruik van setw()

/* programma P113.cpp */ #include #include void main() { cout << “Hello world” << endl; cout << setw(8) << setfill(‘#’) << 45 << endl; }

1.2.5.3 Uitlijnen Volgend programma lijnt de eerste uit te printen kolom links uit en de tweede kolom wordt rechts uitgelijnd. /* programma P114.cpp */ #include #include void main() { double waarden[] = {1.36, 45.14, 8.124, 4589.44568} 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

1.3

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

int y = 10;

//fout

else } 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


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 1.4.1 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

1.4.2 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

1.5 Het type const 1.5.1 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;

1.5.2

// 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 void main() { const int a= 5, b= 10; const int *p= &a; cout<<”Inhoud van p: “ << (void *)p << endl; cout<<”p wijst aan p= &b;

: “ << *p << endl;

// ander vrij adres

cout<<”Inhoud van p: “ << (void *)p << endl; cout<<”p wijst aan

: “ << *p << endl;

}


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 void main() { int a= 5, b= 10; int *const p= &a; cout<<”Inhoud van p: “ << (void *)p << endl; cout<<”p wijst aan a= 10;

: “ << *p << endl;

// 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

1.6.1 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

/* programma P117.cpp */ #include void increment(int); void main() { int i= 3; cout<<”i =

“ << i << endl;

// i = 3

“ << i << endl;

// i = 3

increment(i); cout<<”i = } 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 void increment(int *); void main() { 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.


17

1.6.2 Het type referentie 1.6.2.1 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.

1.6.2.2 Programmavoorbeeld Volgend programma maakt gebruik van een referentie. /* programma P119.cpp */ #include void main() { 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: cout<<”adres van i: ri = 10;

“ << i << endl;

“ <<&i << endl;

// gebruik van i via zijn referentie

cout<<”waarde van i via zijn referentie: int j= ri;

“ << i << endl;

// i= 10

// j krijgt de waarde van i, nl. j= 10

cout<<”waarde van j:

“ << j << endl;

ri++; cout<<”waarde van i: pi = &ri;

“ << i << endl;

// i= 11

// 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.

1.6.3 Initialisatie van een referentie Een referentie kan niet bestaan zonder een variabele waarnaar gerefereerd wordt. Volgende code kan dus niet: int &refint;

// fout

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 void increment(int &); void main() { int i= 3; //int &ri;

//fout: ‘ri’: references must be initialized

int &ri= i; cout<<”i = cout<<”ri =

// declaratie van de referentie ri “ << i << endl;

// i = 3

“ << ri << endl; // ri = 3

increment(ri); // referentie wordt doorgegeven cout<<”i = cout<<”ri =

“ << i << endl;

// i = 4, nieuwe waarde uit increment()

“ << 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= 4

}

1.6.4 Referentie als functieparameter Het referentie datatype is vooral interessant bij het doorgeven van te veranderen parameters naar een procedure. /* programma P121.cpp */ #include void increment(int &); void main() { int i= 3; int &ri= i; cout<<”i = cout<<”ri =

// declaratie van de referentie ri “ << i << endl;

// i = 3

“ << ri << endl; // ri = 3

increment(ri); // referentie wordt doorgegeven cout<<”i = cout<<”ri =

“ << i << endl;

// i = 4

“ << ri << endl; // ri = 4

} void increment(int &ri) { ri++; }


19

1.6.5 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 void main() { int i= 3; int *const ri= &i; cout<<”i =

// ri is een constante pointer naar i

“ << i << endl;

cout<<”ri =

// i= 3

“ << ri << endl; // adres van de geheugenplaats van ri

cout<<”*ri =

“ << *ri << endl;

// 3

increment(ri); // pointer ri wordt doorgegeven cout<<”i =

“ << i << endl;

cout<<”ri =

// i= 4

“ << 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 void main() { int i= 3; int &ri= i; cout<<”ri =

// declaratie van de referentie 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 = cout<<”ri = }

“ << i << endl; “ << ri << endl;

20

2) Een referentie toekennen met een waarde kan niet. /* programma P124.cpp */ #include void main() { 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= 5;

// ri= 3 // dit kan wel

cout<<”i =

“ << i << endl;

cout<<”ri =

“ << ri << endl;

// i= 5 // ri= 5

} 3) Twee referenties vergelijken met elkaar kan. /* programma P125.cpp */ #include void main() { 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 void main() { int i1= 3, i2= 5; int &ri1= i1; int &ri2= i2; cout<<”ri1 + ri2 = “ << ri1+ri2 << endl; }


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 void main() { 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; const int &ri= 5;

// fout: geen lvalue

// 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= 12.8 } 6) Een referentie wijzigen kan niet. /* programma P128.cpp */ #include void main() { 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 void f2(int &r2) { r2*=2; }

22

void f1(int &r1) { f2(r1); } void main() { int i= 7; f1(i); cout<<”i = “ << i << endl;

// i= 4

}

1.6.6 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 int EenNummer= 0; int &num() { return EenNummer; } void main() { 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 int &min(int &ri1, int &ri2) { return(ri1 < ri2 ? ri1 : ri2);

// ri1 refereert naar i1, waardoor i1 blijft // bestaan als de functie is afgelopen

}


23

void main() { 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= 20 }

1.7 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

1.8

Overloaded functies

1.8.1 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.


25

1.8.2 Gebruik Overloading kan het programmeren aanzienlijk vereenvoudigen, zoals getoond in volgend programma. /* programma P132.cpp */ #include int square(int r) { return ( r >= -250 && r <= 250) ? r*r : -1; } long square(long r) { return ( r >= -40263 && 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; }

1.8.3

Functie aanroepen met argumenten van verschillend type

1.8.3.1 Voorbeeld met automatische convertie /* programma P132.cpp */ #include void demo(double); void main(void) { demo(10);

//automatische conversie van int naar double

demo(5.24); } void demo(double a) { cout<< a << “is een double.” << endl; } Resultaat:

10 is een double. 5.24 is een double.

26

1.8.3.2 Voorbeeld met verlies van data /* programma P133.cpp */ #include void demo(int); void main(void) { demo(10);

//warning:’argument’:conversion from ‘const double’ to ‘int’ //possible loss of data

demo(5.24); } 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 1.9.1 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.

1.9.2 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


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> void main() { 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.

1.10 Inline functies 1.10.1 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.

1.10.2 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

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 #define MAX(getal1, getal2)((getal1>getal2)?getal1:getal2)

//macro

void main() { 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 inline MAX(int, int);

//prototype van de inline functie

void main() { 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; }


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.

1.10.3 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. void main() { 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

1.11.1 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

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.

1.11.2 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 #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

} void main() { double afstand1 = afstand(2, 8);

//x1=2, y1=8, x2=0, y2=0

cout<<”afstand1= “ << afstand1 << endl; //afstand1= 8.24621 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.

1.11.3 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++\020819 Programmeren in C++.doc

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 void lijn(char c= ‘-‘, int i= 80) { for (int t= 1; t<=i; t++) cout<< c; cout<< endl; } void main() { lijn();

// afdruk van 80 keer het karakter ‘-‘

lijn(‘=’);

// afdruk van 80 keer het karakter ‘=‘

lijn(‘=’, 20);


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 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; } void main() { lijn();

// afdruk van 80 keer het karakter ‘-‘

lijn(‘=’);


lijn(‘=’, 20);


lijn(30);

// afdruk van 30 keer het karakter ‘#‘

}

32

1.11.4 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.

1.12 New en delete 1.12.1 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++\020819 Programmeren in C++.doc

33

C++ de operator new toegevoegd. Dit is de tegenhanger van malloc() in C. Let op: malloc() en new mogen niet samen gebruikt worden, anders leidt het mengen tot problemen. De operator new biedt het voordeel dat er geen probleem meer is met type-casting, noch met het bepalen van de grootte van de te alloceren ruimte. Daarbij is het mogelijk de nieuwe ruimte onmiddellijk te initialiseren. Enkele voorbeelden: int *p; p= new int;

// er wordt geheugen voorzien, maar niet geïnitialiseerd

p= new int(7); // er wordt geheugen voorzien en geïnitialiseerd met de waarde 7 p= new int [10];

// er wordt geheugen voorzien voor een array van 10 // integers zonder initialisatie

De constructie p= new int [10] (7); is niet toegestaan, omdat arrays van int, char, long, float en double (basistypes) niet kunnen worden geïnitialiseerd. De operator new laat toe om objecten of arrays van objecten te alloceren, zonder dat men expliciet de grootte moet doorgeven die het object inneemt in het geheugen. Bovendien wordt bij de new operator een ‘type check’ gedaan, zodat fouten zoals het alloceren van geheugen voor een int en de teruggekregen pointer toekennen aan een double, vermeden worden. De new operator is noodzakelijk bij het dynamisch alloceren van objecten, daar hij een correcte initialisatie van de objecten toelaat.

1.12.2

De-allocatie van geheugen C++ bezit de operator ‘delete’ om geheugen te de-alloceren. De delete operator is de tegenhanger van de operator free uit C. Echter, de free operator kan geen gealloceerde arrays de-alloceren, delete kan dat wel. Let op: gebruik delete en free niet samen! Mengen leidt tot problemen. Ook zal delete, net als free, niet verifiëren of de meegegeven pointer wel degelijk verwijst naar een gealloceerd object. Enkele voorbeelden: int *p_i = new int; // . . . . delete p_i; int *p_array_int = new int[10]; // . . . . delete [] p_array_int;

1.12.3 Dynamische array In het volgend programma wordt met de operator new een dynamische array van ‘aantal’ integer variabelen aangemaakt. De operator new vraagt aan het besturingssysteem een aaneengesloten geheugenblok voor ‘aantal’ integer variabelen. De new operator levert dan het beginadres op van die geheugenblok. Via dat adres krijgt het programma toegang tot dat geheugenblok.

34

/* programma P139.cpp */ #include void main() { cout<<”Aantal getallen: “; int aantal; cin>>aantal; int *p; p= new int[aantal];

//vraag een dynamische geheugenblok aan //en ken het beginadres toe aan de pointer p

int i, som= 0; for (i= 0; i < aantal; i++) { cout<< (i+1) << “e getal: “; cin>> p[i]; } for (i= 0; i < aantal; i++) som+= p[i]; cout<<”Het gemiddelde is “<<double(som)/aantal << endl; delete[] p;

//delete[] maakt het geheugen vrij dat wordt aangewezen // door p //Het is een goede gewoonte om dynamisch geheugen vrij //te geven als dat geheugen niet meer nodig is

}

1.12.4 Overloaden van de new operator De new operator kan opnieuw gedefinieerd worden door gebruik te maken van overloading. In het volgende voorbeeld maakt de nieuwe new operator gebruik van een statische buffer. /* programma P140.cpp */ #include #include <string.h> const int GROOTTE 1000; static char buffer[GROOTTE]; static char buffer_used = 0; void *operator new(size_t size) { cout<<”new opgeroepen”<<endl; if (size > GROOTTE || buffer_used) return NULL; else { buffer_used = 1; return buffer; } }


35

void operator delete(void *ptr) { cout<<”delete opgeroepen”<<endl; buffer_used = 0; } void main() { char *tekst1 = new char[10]; cout<
1.12.5 Gebruik van de set_new_handler Bij gebruik van de new operator wordt telkens geverifieerd of de teruggegeven pointer niet NULL is. Daarenboven biedt C++ de mogelijkheid om gebruik te maken van de _set _new_handler functie, die de programmeur de mogelijkheid biedt om een foutafhandeling te voorzien die dienst kan doen voor elk geheugenreserveringsprobleem. Deze functie heeft als argument een functie-pointer naar de foutafhandelende functie. Telkens new de aangevraagde hoeveelheid geheugen niet kan toekennen, zal de foutafhandelende functie worden opgeroepen. Het volgend programma illustreert dit. /* programma P141.cpp */ #include #include <string.h> #include //De afhandel-routine moet als argument een size_t parameter hebben en als //return-type int. int afhandel_allocatie_probleem(size_t size) { cerr << “Het geheugenblok van “ << size << “ bytes kan niet gereserveerd worden” << endl; exit(1); return 0; } void main() { _set_new_handler(afhandel_allocatie_probleem); while (1) { char *alloc = new char[1000]; cout << “1000 bytes gereserveerd” << endl; } }

36

1.13 Namespaces 1.13.1 Het concept ‘namespaces’ van C++ Namespaces dienen om ervoor te zorgen dat globale variabelen en routines niet in conflict treden met andere variabelen en routines, die dezelfde naam hebben. Met het concept van ‘namespaces’ kan men definities en variabelen, die tot éénzelfde bibliotheek behoren, groeperen en isoleren van andere bibliotheken om aldus conflicten te vermijden tussen bijvoorbeeld twee routines met dezelfde naam in verschillende bibliotheken. In het volgend voorbeeld is een namespace A gedefinieerd die volgende elementen groepeert: -

de variabele j

-

de variabele str

-

het object EenObj

-

de klasse-definitie EenKlasse

namespace A { int j; char str[30]; class EenKlasse { …. }; class NogEenKlasse; NogEenKlasse EenObj; }

1.13.2 Gebruik van variabelen Er zijn twee mogelijkheden om variabelen te gebruiken, die behoren tot een namespace: 1) Men specificeert expliciet de namespace. Voorbeeld: A::j = 3; strcpy(A..str, “EenString”); 2) Men gebruikt het sleutelwoord ‘using namespace’. Voorbeeld: using namespace A; j = 3; strcpy(str, “EenString”);


37

1.14 Commentaar C++ voorziet in een nieuwe stijl van commentaar: hij begint na een dubbele slash en eindigt met enter. Voorbeelden: // Dit is commentaar in C++ int i = 32767; // hoogste waarde van een signed int De nieuwe commentaarstijl is niet bruikbaar om midden in een regel commentaar te schrijven. Volgende regel is fout: for (i= 0; i<32767 //hoogste waarde van een signed int//; i++); De commentaarstijl van C mag nog steeds gebruikt worden, zodat vorige regel dan wel kan: for (i= 0; i<32767 /*hoogste waarde van een signed int*/; i++);

1.15 Oefeningen 1) Overloading. Bereken de oppervlakte van een rechthoek en van een vierkant met behulp van éénzelfde functie oppervlakte(). 2) Referenties. Verwissel de waarde van twee getallen met behulp van de functie verwissel() en met gebruik van referenties. 3) Schrijf een programma dat het getal 65 decimaal, hexadecimaal, octaal, binair en als teken op het scherm zet. 4) Schrijf een programma dat de getallen 1000, 100, 10 en 1 mooi onder elkaar plaatst: eenheden onder elkaar, tientallen onder elkaar, enz…. 5) Default argumenten. Schrijf een programma dat verschillende versies van de functie lijn() bevat zodat onderstaande main() gebruikt kan worden. void main() { lijn(); lijn(33); lijn(33, ‘t’); lijn(‘=’); char dummy[2]; cin.getline(dummy, 2); }

38

2. Klassen en objecten 2.1 Creatie van een nieuw datatype in C++ 2.1.1 Het datatype klasse De taal C beschikt over de structuur (E: structure). Een structuur is de samenhangende verzameling (collectie) van variabelen, die van verschillend type kunnen zijn. Voorbeeld van struct: Stel dat we volgende gegevens van clubleden willen beschrijven: naam en volgnummer. Daartoe declareren we een struct Clublid met de leden (data) naam en volgnummer: struct Clublid { char naam[40]; int volgnummer; }; Een belangrijk nieuw aspect van C++ is dat een structuur, naast de data, nu ook functies, de zgn. lidfuncties, kan bevatten. Dit is het nieuwe datatype: de klasse (E: class). Een klasse is dus een samengesteld datatype zoals een struct, die echter naast de data-elementen, ook lidfuncties bevat. De private data-elementen van een klasse kunnen enkel gemanipuleerd worden door de lidfuncties van die klasse. Voorbeeld van klasse: class Clublid { private: char naam[40]; int volgnummer; public: Clublid(char *lidnaam, int nummer= 0) { strcpy(naam, lidnaam); volgnummer= nummer; } } In een klasse worden data en de toegestane bewerkingen op die data samengevoegd, hetgeen misverstanden en misbruik voorkomt. de verzameling data-elementen representeren de klasse de bewerkingen die toegepast kunnen worden op de data-elementen van die klasse, vormen de verzameling lidfuncties. De lidfuncties worden ook wel de interface van de klasse genoemd.


39

2.1.2

Programma-voorbeeld 1 en bespreking. /* programma P142.cpp */ #include #include <string.h> class Artikel { char btwcode; //deze data-elementen zijn default private int prijs;

//en kunnen enkel worden aangewend door

char *naam;

//de lidfuncties van de klasse Artikel

public: char *get_naam()

//public lidfunctie met definitie

{ cout<<”Geef naam: “; cin>>naam; return naam; } float get_btwpercentage();

//declaratie van public lidfuncties

int get_prijs();

//definities volgen later

}; float Artikel::get_btwpercentage() {

//definitie van lidfunctie //:: is de scope operator

cout<<”Geef btwcode: “; cin>>btwcode; return btwcode == ‘H’ ? 21.00 : 6.00; } int Artikel::get_prijs()

//definitie van lidfunctie

{ cout<<”Geef prijs: “; cin>>prijs; return prijs; } void main() { Artikel art;

//art is een object van de klasse Artikel

int pr;

//lokale variabelen voor main()

float btw; char *n; n= art.get_naam();

//toekenning gebeurt via

pr= art.get_prijs();

//de lidfuncties van

btw= art.get_btwpercentage();

//de klasse Artikel

cout<<endl; cout<<”naam= “<< n <<endl; cout<<”prijs= “ << pr << endl; cout<<”btwpercentage= “ << btw << endl; }

40

In bovenstaand programma is de klasse Artikel gedefinieerd met een aantal dataelementen en een aantal lidfuncties. Een lidfunctie onderscheidt zich van een dataelement door het gebruik van ronde haakjes. De klasse Artikel kan enkel aangewend worden via objecten van de klasse Artikel. In het programma is art een object van de klasse Artikel. De klasse Artikel is te beschouwen als een model, als een shabloon, terwijl het object art een instantie is van de klasse Artikel. Een zeer beknopte omschrijving van klasse en object is: een klasse is een specificatie voor objecten, terwijl een object een variabele is die gemaakt is volgens deze specificatie. De lidfunctie get_naam() is gedefinieerd in de klassedefinitie. Dergelijke lidfuncties worden automatisch behandeld als inline-functies. Doordat inline-functies alleen nuttig zijn als ze klein zijn, worden enkel kleine functies binnen de klassedefinitie geplaatst. De lidfuncties get_btwpercentage() en get_prijs() zijn gedefinieerd buiten de klassedefinitie. Zo’n functie moet echter wel binnen de klassedefinitie worden gedeclareerd. Zo weet de compiler dat de functiedefinitie nog komt. Een functiedefinitie buiten de klassedefinitie wordt gekenmerkt door vóór de functienaam de klassenaam en de bereikoperator :: op te nemen, bijvoorbeeld: int Artikel::get_prijs(). Deze notatie zorgt ervoor dat de functie get_prijs() wordt gekoppeld aan de klasse Artikel. De data-elementen btwcode, prijs en naam zijn private leden van de klasse Artikel. Dit betekent dat die data-elementen enkel toegankelijk zijn voor lidfuncties van de eigen klasse. Uiteraard moeten dan die lidfuncties public toegankelijk zijn om ze te kunnen gebruiken in main(). Immers, de publieke leden van een klasse vormen de interface tot die klasse, dit is de verbinding met die klasse. Om bijvoorbeeld in main() het data-element prijs een waarde toe te kennen, moet gebruik worden gemaakt van de lidfunctie get_prijs() en wel als volgt: pr = art.get_prijs(); met pr een gewone variabele (niet een privaat data-element van de klasse) en met art een object van de klasse waartoe prijs behoort. Volgende toekenning levert een fout op: pr= art.prijs; //error: ‘prijs’ cannot access ‘private’ member declared in // class ‘Artikel’ Ook kan een lidfunctie niet worden gebruikt zonder een object van zijn klasse. int pr; pr= get_prijs();

// error

Lidfuncties van een klasse onderscheiden zich van gewone functies door volgende kenmerken: 1) Lidfuncties hebben een volledige toegangsprivilege tot zowel de publieke als de private leden van de klasse waartoe ze behoren. Gewone functies hebben enkel toegang tot de publieke leden van een klasse. Uiteraard hebben de lidfuncties van de ene klasse geen toegang tot de leden van een andere klasse. 2) Lidfuncties worden gedefinieerd binnen het bereik van de klasse waartoe ze behoren. Gewone functies worden gedefinieerd binnen het bestandsbereik. Dit betekent dat namen van lidfuncties niet zichtbaar zijn buiten het bereik van de klasse. T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

41

2.1.3 Programma-voorbeeld 2 en bespreking Volgend programma is bedoeld om datums (dag, maand en jaar) te manipuleren. Het programma moet beletten dat een foutieve datum (bv. 51/14/200) kan worden toegekend. Verder moet het mogelijk zijn om de datum-structuur te kunnen wijzigen, bv. short int voor dag i.p.v. int, zonder ons te moeten bekommeren welke functies er mee te maken hebben, die uiteraard ook moeten worden aangepast. De oplossing is functies te definiëren die de variabelen van de datum aanspreken en respectievelijk dag, maand en jaar teruggeven en/of wijzigen, en waarbij we de conventie aannemen dat enkel deze functies mogen gebruikt worden om toegang te hebben tot de verschillende onderdelen van de datum. We definiëren met andere woorden een set van functies die de toegang regelen tot deze variabelen. Daardoor kunnen we checken of de elementen van de datum wel degelijk correct toegekend worden, en bovendien zal bij een verandering van de structuur alleen deze functies dienen te worden veranderd. Dit betekent het gebruik van een klasse. /* programma P143.cpp */ #include class Datum { public: Datum(int dag, int maand, int jaar); void ToonDatum; private: int dag, maand, jaar; }; inline int max(int a, int b) { if (a > b) return a; return b; } inline int min(int a, int b) { if (a < b) return a; return b; } Datum::Datum(int eendag, int eenmaand, int eenjaar) { static int lengte[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; maand= max(1, eenmaand); maand= min(maand, 12); dag= max(1, eendag); dag= min(dag, lengte[maand-1]); jaar= max(1, eenjaar); }

42

void Datum::ToonDatum() { static char *maandnaam[] = { “januari”, “februari”, “maart”, “april”, “mei”, “juni”, “juli”, “augustus”, “september”, “oktober”, “november”, “december” }; cout<
// verkeerde datum!

Geboortedatum.ToonDatum(); Verkeerdedatum.ToonDatum(); } Dit programma geeft als resultaat: 21 juli 1966 31 december 1966 Bespreking: Altijd moet gestart worden met de definitie van de klasse (hier Datum). Deze definitie bevat zowel de data-elementen als de lidfuncties die deze klasse uitmaken. In main() worden de objecten gedefinieerd die tot de klasse Datum behoren. Een object is een instantie van een klasse, dit wil zeggen, het is een aanwijsbaar ‘voorwerp’ van een abstracte klasse. In bovenstaand programma is een ‘geboortedatum’ inderdaad een specifieke datum behorend tot de abstracte klasse Datum. Een klasse is een abstract datatype, net zoals een struct. Een object wordt geconstrueerd door middel van een constructor, hier de constructor Geboortedatum(). Deze constructor is een functie die altijd dient opgegeven te worden. Het doel van een constructor is de initialisatie te doen van de data-elementen behorend tot het object. Het is de taak van de constructor om de data-elementen te initialiseren met geldige waarden. Zelfs wanneer we een object willen creëren waarbij we ongeldige variabelen doorgeven, dan moet de constructor ervoor zorgen dat deze toch een geldige waarde krijgen, bv. het object Verkeerdedatum. We spreken niet rechtstreeks de data-elementen van het object aan, maar doen dit onrechtstreeks bij de initialisatie van het object via het oproepen van de constructor. Het rechtstreeks aanspreken van het element wordt vermeden door ze als private te declareren. We zeggen dat de inwendige structuur van het object verborgen blijft voor de gebruiker van het object. De data-elementen van een object worden rechtstreeks aangesproken door de lidfuncties. Het is niet nodig om expliciet de naam van het object mee te geven zoals met structuren wel het geval is. De lidfuncties weten op welk object moet ingewerkt worden. Het aanroepen van de leden van een klasse gebeurt door middel van de ‘.’ operator, net zoals bij structuren. Merk op dat ook de lidfuncties op dezelfde T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

43

manier worden aangesproken. Dit drukt uit dat deze functies inderdaad behoren tot het object, en niet zomaar los staan van het object. Functies die inwerken op de leden van een struct, staan wel los van die struct. De data-elementen van een klasse worden op dezelfde wijze gedeclareerd als gewone variabelen. Echter is de expliciete initialisatie van data-elementen niet toegestaan. In het programma-voorbeeld is volgende expliciete initialisatie van het dataelement dag niet toegelaten: int dag= 12; Een klasse-object kan enkel als data-element worden gedeclareerd als de klassedefinitie ervan reeds is geconstateerd. In die gevallen waarvoor de klassedefinitie nog niet is geconstateerd, kan een vóórdeclaratie van de klasse worden gegeven. Voorbeeld: class Geboortedatum;

//vóórdeclaratie

class Clublid { Geboortedatum *p;

//pointer p naar klasse Geboortedatum

}; Dankzij de vóórdeclaratie kan p gedeclareerd worden.

2.2 Definitie van een klasse en OOP 2.2.1 Definitie van een klasse Een klasse is per definitie een door de programmeur gedefinieerd datatype dat zowel data-elementen als procedurele-elementen (lidfuncties) bevat. In het geheugen is een klasse opgebouwd uit de data-elementen die deze klasse bevat. De functies die tesamen met de klassedefinitie worden opgegeven zijn gewone aan te roepen functies die, weliswaar verborgen, een bijkomende parameter bevatten, nl. de pointer ‘this’ naar het eerste data-element van deze klasse. Volgend schema verduidelijkt dit: Geheugen

Data_1 Proc_1(this, …) Data_2

Proc_2(this, …)

{

{

…

…

}

}

Data_n

Bovenop dit wat simplistisch model biedt de compiler de programmeur bijkomende functionaliteit aan, die toelaten alle aspecten van een klasse te benutten: Informatieverberging (E: data-hiding), die toelaat bepaalde elementen te beschermen tegen ongeoorloofd gebruik. De data die een object nodig heeft, zit opgeslagen in het object zelf (E: encapsulation). Die data zullen meestal niet

44

zichtbaar zijn voor de gebruiker. Die data zal bewerkt worden door lidfuncties, die ook deel uitmaken van het object. De ontwerper van de klasse bepaalt wat voor lidfuncties de gebruiker(programmeur) kan aanwenden en welke niet. De ontwerper bepaalt ook wat voor date de gebruiker rechtstreeks zal kunnen aanwenden en welke niet. Constructors die toelaten objecten te initialiseren. Overerving (E: inheritance), die toelaat eigenschappen over te dragen van een basisklasse naar een afstammeling ervan. Van bestaande klassen kunnen nieuwe klassen worden afgeleid. Deze nieuwe klassen erven de data en lidfuncties van de generieke klasse, ook superklasse genoemd. In de subklasse, ook specifieke klasse genoemd, kunnen we functies herdefiniëren of weglaten. Ook kunnen data-elementen worden toegevoegd aan een subklasse. Polymorfisme (E: polymorphism) of veelvormigheid is het principe waarbij een afgeleid object kan worden aangesproken alsof het een basisobject is. Polymorfisme laat toe om een procedure, lid van een bepaald object, iets anders te laten uitvoeren naargelang het type van het object. Met behulp van de techniek van polymorfisme kan een verzameling van gelijksoortige objecten worden aangelegd, en kan op deze verzameling dan een gemeenschappelijke functie worden uitgevoerd. Elk van de elementen van die verzameling zal dan reageren zoals voor dat type object voorzien is.

2.2.2 OOP 2.2.2.1 OOP versus procedureel programmeren OOP staat voor Object Oriented Progamming, in het Nederlands: object georiënteerd programmeren. OOP maakt gebruik van klassen en objecten. Het verschil tussen OOP en procedureel programmeren (zoals in C) is veel groter dan enkel klassen en objecten, het is een manier van aanpak. Bij procedureel programmeren vertrek je vanuit de bewerkingen die op data moeten worden uitgevoerd. Je giet die bewerkingen in functies op basis van het top-down mechanisme. Bij OOP vertrek je vanuit de objecten en ga je na wat voor data die objecten gebruiken en wat voor bewerkingen van toepassing zijn op dat object.

2.2.2.2 De principes van OOP 1) Abstractie. Abstractie houdt in dat de gebruiker kan werken met objecten zonder zich te moeten bekommeren om de implementatiedetails van het object. Een object is een instantie van een klasse. De implementatiedetails van een klasse zijn voor rekening van de ontwerper van die klasse, niet voor rekening van de gebruiker van die klasse. De programmeur die een klasse ontwerpt en objecten van die klasse gebruikt in een programma, is terzelfder tijd ontwerper en gebruiker. 2) Data-verberging en inkapseling. 3) Overerving. 4) Polymorfisme. Meer uitleg staat in deel 8.


45

2.3 Opbouw van een klasse Bij de definitie van een klasse worden de lidfuncties en lidvariabelen (dataelementen) gespecificeerd voor deze klasse. Eens gedefinieerd, wordt een klasse behandeld alsof het een nieuw type is. Beschouwen we volgend voorbeeld: class auto { public: int snelheid;

// lidvariabele

int verbruik;

// lidvariabele

int leeftijd;

// lidvariabele

void starten();

// lidfunctie

void rijden();

// lidfunctie

void remmen();

// lidfunctie

int BerekenVerbruik(); // lidfunctie }; Het creëren van een object behorend tot de klasse auto gebeurt zoals voor een ander datatype. Enkele voorbeelden: auto Volkswagen; auto Oldtimers[10[; auto *AutoPtr = &Volkswagen; Het public gedeelte in de klassedefinitie specificeert dat de lidvariabelen en lidfuncties toegankelijk zijn voor de gebruikers van de klasse. Volgende assignatie van publieke lidvariabelen is toegelaten: Volkswagen.snelheid = 70; Volkswagen.leeftijd = 5; Oldtimer[1].leeftijd = 40; AutoPtr -> verbruik = 12; Publieke lidfuncties kunnen met dezelfde schrijfwijze als de lidvariabelen worden aangeroepen, zoals volgende voorbeelden tonen: AutoPtr -> remmen(); Oldtimer[3].starten(); Volkswagen.rijden(); Vóór de definitie van een lidfunctie moet de klasse worden meegegeven. Zo wordt aangegeven dat deze functie-definitie behoort tot de aangeduide klasse. Beschouwen we volgend voorbeeld: void Auto::starten(void) { Draai_contactsleutel_om(); Zet_in_eerste_versnelling(); Geef_gas(); } Het paar ‘dubbele punten’ (::) wordt de bereikoperator (scope resolution operator) genoemd. Deze operator laat immers toe het bereik (namelijk dat van de klasse)

46

van de functie aan te duiden. Indien we dus Auto:: laten voorafgaan aan de functiedefinitie, dan indiceren we dat de functie lid is van de klasse Auto. Merk op dat we onmiddellijk gebruik kunnen maken van de gedefinieerde variabelen in de definitie van lidfuncties. We kunnen dus het volgende schrijven: int Auto::BerekenVerbruik() { if (snelheid > 90) verbruik = 10; else verbruik = 8; } Het is dus niet noodzakelijk om de operator -> of . te gebruiken, zoals dit noodzakelijk was bij het gebruiken van een structuur. Binnen een definitie van een lidfunctie strekt de zichtbaarheid van de variabelen uit over alle leden van de klasse waartoe de lidfunctie behoort. Met andere woorden, het aanroepen van de functie BerekenVerbruik() van een object zal automatisch de juiste data-elementen hanteren. Bijvoorbeeld: Auto Mercedes, Ford;

//objecten Mercedes en Ford van de klasse Auto

1: Mercedes.BerekenVerbruik(); 2: Ford.BerekenVerbruik(); De functie BerekenVerbruik() op lijn 1 zal inwerken op de data-elementen snelheid en verbruik van het object Mercedes, en op lijn 2 op de data-elementen van het object Ford.

2.4 Toegangscontrole tot klasseleden Om de toegang tot leden van een klasse te regelen heeft de programmeur de beschikking over drie mgelijkheden: 1) Een ‘private’ lid is enkel toegankelijk voor lidfuncties van dezelfde klasse als van het private lid en voor friends van die klasse. Dit is de meest strikte toegangsvorm. Zelfs via een object van die klasse is een privaat lid niet toegankelijk. 2) Een ‘protected’ lid is enkel toegankelijk voor lidfuncties van dezelfde klasse als van het protected lid, voor friends van de klasse en ook voor lidfuncties van publiek afgeleide klassen. Zelfs via een object van die klasse is een beschermd lid niet toegankelijk. 3) Een ‘public’ lid is toegankelijk voor iedereen. De publieke leden vormen als het ware de interface tot deze klasse. Met behulp van de publieke leden communiceren we met het ‘inwendige’ van het object. Het inwendige van het object wordt op zijn beurt gevormd door de private leden van het object. Deze private leden zijn niet zichtbaar van buiten uit. Ze zijn enkel toegankelijk via de publieke leden van het object. Een beschermd lid vormt de middenweg tussen een privaat lid en een publiek lid. Een beschermd lid is niet toegankelijk, maar kunnen in afgeleide klassen wel aangesproken worden. T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

47

Private data-elementen worden gewoonlijk voorbehouden voor data die moet beschermd worden tegen foutieve initialisaties, bv. voor data die alleen een bepaalde set van waarden kan aannemen. De toegang tot zo’n data-element wordt gewoonlijk verzorgd door een publiek lidfunctie, die de initialisatie van het dataelement controleert. Ook elementen die intern geïnitialiseerd worden, bv. met behulp van de constructor, worden privé gehouden. Herschrijven we vorige klasse auto, gebruik makend van de toegangscontrole: class auto { private: int verbruik;

// niet zelf te bepalen

int leeftijd;

// dus private

int snelheid;

// wel zelf te bepalen

public: int kleur; auto(); void starten();

// functies die extern

void rijden();

// aangeroepen worden

void remmen(); int BerekenVerbruik; ~auto();

//~ = alt 126, staat voor destructor

inline void ZetVerbruik(int EenVerbruik); inline void ZetLeeftijd(int EenLeeftijd); inline int GeefVerbruik(); inline int GeefLeeftijd(); }; inline void auto::ZetVerbruik(int EenVerbruik) { if (EenVerbruik < 1) verbruik= 1; else if (EenVerbruik > 30) verbruik= 30; else verbruik = EenVerbruik; } inline void auto::ZetLeeftijd(int EenLeeftijd) { if (EenLeeftijd < 0) leeftijd= 0; else if (EenLeeftijd > 30) leeftijd= 30; else leeftijd = EenLeeftijd; } inline int auto::GeefVerbruik() { return verbruik; } inline int auto::GeefLeeftijd() { return leeftijd; }

48

We kunnen dan het volgende schrijven: void MijnAuto(void) { auto Ford;

//creatie van object Ford

Ford.kleur = grijs;

//OK: kleur is public

Ford.snelheid = 60; Ford.leeftijd = 100;

//fout: leeftijd is private

Ford.ZetLeeftijd(100);

//OK: toegang via lidfunctie

int EenLeeftijd = Ford.GeefLeeftijd(); Ford.ZetVerbruik(10); } In bovenstaand voorbeeld is gebruik gemaakt van de functies ZetLeeftijd() en ZetVerbruik() om de private data-elementen een waarde toe te kennen. Deze functies bieden het voordeel dat ze expliciet de doorgegeven parameter verifiëren op hun correctheid en eventueel correctieve acties uitvoeren. Voor het aanspreken van de private data-elementen wordt gebruik bemaakt van de functies GeefLeeftijd() en GeefVerbruik().

2.5 Constructoren en destructor 2.5.1 Constructor Een constructor is een speciale lidfunctie die -

dezelfde naam heeft als de klasse waar hij lid van is

-

automatisch wordt uitgevoerd zodra een nieuw object van die klasse gemaakt wordt

-

zorgt voor de initialisatie van een object

-

geen return-type heeft, zelfs geen void, m.a.w. een constructor heeft geen return value (terugkeerwaarde)

Er mogen meerdere constructoren in een programma voorkomen. De constructor is verantwoordelijk voor het creëren van het object. Met andere woorden, telkens een constructor wordt opgeroepen zal er ruimte in het geheugen worden voorzien voor het object. Dit betekent ook dat het verboden is om rechtstreeks vanuit een lidfunctie een constructor op te roepen. Meestal is de belangrijkste, en enige taak van een constructor het geven van een beginwaarde aan de data-leden(initialiseren). Omdat constructoren vrij eenvoudige taken uitvoeren, worden ze dikwijls inline gedefinieerd. Voorbeeld: class Datum { private: int dag; int maand; int jaar;


49

public: //constructor Datum() { dag= 1; maand= 1; jaar= 2002; } // … overige lidfuncties }; De constructor Datum() van de klasse Datum stelt de datum in op 1 januari 2002. Bij elk object van de klasse Datum, dat wordt gedeclareerd, wordt de constructor Datum() aangeroepen. Dus, na de declaratie Datum d1, d2; Zijn zowel d1 als d2 automatisch geïnitialiseerd met 1 januari 2002. Programmavoorbeeld: De klasse Telgids laat toe om gegevens van een telefoongids te combineren. /* programma P144.cpp */ #include #include <string.h> class Telgids { public: Telgids(const char *na, int num)

// constructor

{ naam = new char[strlen(na)+1]; strcpy(naam, na); nummer= num; } void print() { cout<
// impliciete constructoraanroep

50

De private leden naam en nummer kunnen enkel worden aangewend door de lidfuncties van de klasse Telgids, nl. door de constructor Telgids en de lidfunctie print(). Omdat de lidfuncties publiek zijn (gelukkig), kunnen ze worden aangeroepen buiten de klasse Telgids. In het voorbeeld is dit in main(). In main() wordt het object t1 gecreërd van het type klasse Telgids. De constructor Telgids() zorgt ervoor dat het object t1 geïnitialiseerd wordt met de opgegeven string “Jansens” en de integer 3456. Merk op dat volgende aanroepen van de constructor Telgids() fout zijn, omdat de constructor Telgids() twee argumenten verwacht: Telgids t1;

// fout

Telgids t1(3456);

//fout

Via t1 kan de publieke lidfunctie print() van de klasse Telgids() worden aangeroepen. Dit houdt in dat de afdruk van de naam en het nummer vast ligt en volledig bepaald is door de lidfunctie print().

2.5.2 Default constructor De constructor Datum() in voorbeeld van 2.5.1 heeft geen argumenten. Een constructor zonder argumenten heeft een speciale naam: de default constructor. De default constructor wordt aangeroepen bij het creëren van een object, als bij de creatie van dat object geen initiële waarden zijn opgegeven. Dit geldt ook bij het aanmaken (alloceren) van een array van objecten, waarbij voor elk array-element de default constructor wordt aangeroepen. Wanneer een klasse geen enkele constructor heeft, zal de compiler zelf een default constructor aanmaken. Zo’n default constructor, gegenereerd door de compiler, doet niets anders dan een object construeren. /* programma P145.cpp */ #include #include <string.h> class Telgids { public: Telgids()

// default constructor

{ naam = new char[8]; strcpy(naam, “niemand”); nummer= -1; } void print() { cout<

51

private: char *naam; int nummer; }; void main() { Telgids kantoor ;

// aanroep default constructor

Telgids afdelingen[3]; // 3 x de default constructor kantoor.print(); for (int i= 0; i < 3; i++) afdelingen[i].print(); } Het programma geeft volgend resultaat: niemand

-1

niemand

-1

niemand

-1

niemand

-1

2.5.3 Constructor met argumenten Een constructor kan argumenten hebben, zodat bij de declaratie van een object dat object meteen kan geïnitialiseerd worden met vrij gekozen waarden. Voorbeeld: Volgende klasse heeft een constructor met drie argumenten. class Datum { private: int dag; int maand; int jaar; public: //constructor met drie argumenten Datum( int d, int m, int j) { dag= d; maand= m; jaar= j; } // … overige lidfuncties }; Een voorbeeld van mogelijke declaratie: Datum d1(10, 12, 2002); Deze declaratie kan als volgt worden gelezen: Declareer een object d1 van de klasse Datum, en geef d1 de initiële waarden 10, 12 en 2002 met behulp van de constructor van deze klasse.

52

Vervelend is nu wel dat het niet meer mogelijk is een object te declareren zonder initiële waarden. Een declaratie als Datum d2; levert een foutmelding op omdat de constructor drie argumenten heeft en daarom drie initiële waarden verwacht. Er zijn twee oplossingen voor dit probleem: 1) Definitie van een tweede constructor (constructor overloading). 2) De drie argumenten van de constructor een default waarde geven.

2.5.4 Constructor overloading Als een klasse meer dan één constructor heeft, is er sprake van constructor overloading. Constructor overloading wordt veel toegepast omdat het flexibele declaraties van objecten mogelijk maakt, bijvoorbeeld declaraties zonder en met initiële waarden. Voorbeeld: class Datum { private: int dag; int maand; int jaar; public: //constructor zonder argumenten (default constructor): Datum() { dag= 1; maand= 1; jaar= 2002; } //overloaded constructor met drie argumenten: Datum( int d, int m, int j) { dag= d; maand= m; jaar= j; } // … overige lidfuncties }; Het is nu mogelijk objecten te declareren met en zonder initiële waarden: Datum d1;

// aanroep constructor zonder argumenten

Datum d2(12, 10, 2000);

//aanroep constructor met 3 argumenten

Voor constructor overloading gelden dezelfde regels als voor het overloaden van functies, nl. de compiler moet op grond van het aantal argumenten en hun type (de zgn signatuur van de functie) eenduidig kunnen beslissen voor één van de constructoren. Als er geen eenduidigheid is, dan heet dat ambiguïteit.


53

Volgend voorbeeld is ambigu. class Datum

// dit voorbeeld is niet correct

{ private: int dag; int maand; int jaar; public: Datum(int d) { dag= d; } Datum(int m) { maand= m; } // … overige lidfuncties }; Datum d(5);

// compiler weet niet welke constructor te gebruiken.

Omdat beide constructoren één argument hebben die een int-waarde accepteren, kan de compiler niet beslissen welke van de twee constructoren hij zal aanvragen. Dit leidt tot een foutmelding.

2.5.5 Constructor met default argumenten Net zoals bij functies, kan men een constructor default argumenten geven. Die default argumenten worden dan gebruikt als bij de declaratie van een object één of meer initiële waarden ontbreken. Een constructor met default argumenten is ook een default constructor. Voor de klasse Datum zou een constructor met default argumenten bijvoorbeeld kunnen zijn: Datum(int d= 1, int m= 1, int j= 2002) { dag= d; maand= m; jaar= j; } Volgende declaraties zijn dan geldige declaraties: Datum d1;

// 1 januari 2002

Datum d2(5);

// 5 januari 2002

Datum d2(5, 10);

// 5 oktober 2002

Datum d2(5, 10, 2001)

// 5 oktober 2001

54

2.5.6 Constructor overloading en default argumenten 2.5.6.1 Probleem en oplossing Als tegelijk constructor overloading en default argumenten worden toegepast, ontstaat er vlug ambiguïteit. Volgend voorbeeld toont dit aan. // constructor zonder argumenten, dus een default constructor Datum() { dag= 1; maand= 1; jaar= 2000; } // constructor met drie default argumenten, ook een default constructor Datum(int d= 1; int m= 1, int j= 2000) { dag= d; maand= m; jaar= j; } Alhoewel de constructor met drie argumenten er anders uitziet dan de constructor zonder argumenten, treedt toch ambiguïteit op, omdat bij een declaratie zonder initiële waarden, zoals bijvoorbeeld Datum d6;, de compiler niet kan beslissen welke constructor te nemen. Immers, er zijn twee default constructoren, nl. twee constructoren die zonder argumenten kunnen worden gebruikt, en dit leidt tot ambiguïteit. Een oplossing voor het probleem van ambiguïteit is één constructor weglaten. Een andere oplossing is het aantal default argumenten in de tweede constructor te verminderen, als volgt: //constructor met drie argumenten, waarvan één default: Datum(int d, int m, int j= 2000) { dag= d; maand= m; jaar= j; } Om deze constructor te kunnen gebruiken, moeten er in elk geval twee initiële waarden worden opgegeven, nl. één voor de dag en één voor de maand.

2.5.6.2 Programma voorbeeld /* programma P146.cpp */ #include #include class Datum { private: int dag; int maand; int jaar; public: T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

55

// default constructor: Datum(int d= 1; int m= 1, int j= 2000) { dag= d; maand= m; jaar= j; } // overige lidfuncties: void verander(int d, int m, int j) { dag= d; maand= m; jaar= j; } void print(); }; void Datum::print() { cout << setfill(‘0’) <<setw(2) << dag << ‘-‘ << setw(2) << maand << ‘-‘ << setw(4) << jaar << endl; } void main() { // declaratie en initialisatie met 1 januari 2000: Datum d1; d1.print(); d1.verander(12, 8, 2001); d1.print(); // declaratie en initialisatie met 4 juni 1980: Datum d2(4, 6, 1980); d2.print(); } De uitvoer is: 01-01-2000 12-08-2001 04-06-1980

2.5.7 Destructor De destructor zorgt ervoor dat de nodige opkuis gebeurt telken een object wordt vernietigd. Wanneer een object wordt vernietigd, dan wordt de destructor automatisch opgeroepen en zorgt voor de opkuis, nl. het de-alloceren van het toegewezen geheugen. Een globaal gedefinieerd object wordt vernietigd als het programma wordt verlaten. Dynamisch gealloceerde objecten worden vernietigd met delete.

56

Objecten die binnen een functie zijn geïnstalleerd worden vernietigd als die functie wordt verlaten. De naam van een destructor is gelijk aan de naam van zijn klasse, echter wel voorafgegaan door ~ (tilde, Alt 126). Een destructor heeft geen terugkeertype en geen argumenten en kan dus niet worden overloaden. In tegenstelling tot constructoren, kan slechts één destructor worden gedefinieerd voor een klasse. In volgend programma wordt naargelang het aantal argumenten een andere constructor aangeroepen. Bij het verlaten van main(), dus bij exit programma, wordt de destructor drie keer aangeroepen in omgekeerde volgorde van de aanroepen van de constructoren. /* programma P147.cpp */ #include #include <string.h> class Telgids { private: char *naam; int nummer; int zone; public: Telgids(const char *na, int num)

// constructor1

{ cout<<”constructor1 aangeroepen”<<endl; naam = new char[strlen(na)+1]; strcpy(naam, na); nummer= num; zone= -1;

// ongeldige zone

} Telgids();

// declaratie van constructor2

Telgids(const char *na, int num, int znr)

// constructor3

{ cout<<”constructor3 aangeroepen”<<endl; naam = new char[strlen(na)+1]; strcpy(naam, na); nummer= num; zone= znr; } void print() { cout<<”naam

= “<
cout<<”nummer

= “<
cout<<”zone

= “<
} }; T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

57

Telgids::Telgids()

// definitie van constructor2

{ cout<<”constructor2 aangeroepen”<<endl; naam = “Piet”; nummer= 20; zone= 2; } Telgids::~Telgids()

// destructor

{ delete[] naam; nummer = 0; zone= 0; } void main() { Telgids t1(“Janssens”, 3456);

// aanroep constructor1

t1.print(); Telgids t2;


t2.print(); Telgids t3(“Els”, 34, 2);


t3.print(); }

2.6 Object als argument van een lidfunctie Wanneer een lidfunctie de gegevens van meerdere objecten nodig heeft, moet die lidfunctie de bedoelde objecten als argument hebben. Volgend programma maakt de som van de inhoud van twee spaarbussen. In elke spaarbus steken stukken van éénEuro en van tweeEuro. De som wordt gemaakt in de lidfunctie som() en moet worden toegekend aan het object totaal. De lidfunctie som() wordt als volgt opgeroepen: totaal.som(bus1, bus2); Dit betekent: stuur naar het object totaal het bericht dat hij de som moet maken van bus1 en bus2. Het resultaat wordt opgeslagen in totaal. De lidfunctie som() moet dus twee argumenten hebben, nl. twee objecten van het type Spaarbus: bus1 en bus2. Programma: /* programma P148.cpp */ #include class Spaarbus { private: int éénEuro, tweeEuro, totaal;

58

public: // constructor met default argumenten: Spaarbus(int stuk1= 0, int stuk2= 0) { éénEuro= stuk1; tweeEuro= stuk2; bereken(); } // overige lidfuncties: void bereken(); void print(); void som(Spaarbus, Spaarbus); }; void Spaarbus::bereken() { totaal= éénEuro * 1 + tweeEuro * 2; } void Spaarbus::print() { cout<<”totaal aantal stukken van éénEuro: “<<éénEuro<<endl; cout<<”totaal aantal stukken van tweeEuro: “<
59

De objecten b1 en b2 zijn value-argumenten en bevatten dus kopieën van bus1, respectievelijk bus2. De constructor van de klasse Spaarbus roept de lidfunctie bereken() aan, zonder dat er een object wordt opgegeven. Van welk object wordt de inhoud berekend? Van het object dat op dat moment door de constructor gemaakt wordt, dus op basis van de declaratie Spaarbus bus1(15, 10) wordt vanuit de constructor de lidfunctie bereken() toegepast op het object bus1.

2.7 Constante objecten en constante lidfuncties 2.7.1

Constante objecten Bij het declareren van een object kan men gebruik maken van het sleutelwoord const, net zoals dat mogelijk is bij het declareren van een gewone variabele. Een declaratie van een object met const betekent dat het object constant is en dus niet kan gewijzigd worden. Bijvoorbeeld: const Datum geboortedatum(24, 5, 1980); In het voorbeeld is geboortedatum een constant object dat niet kan gewijzigd worden.

2.7.2 Constante lidfuncties Doordat constante objecten niet gewijzigd kunnen worden, verbiedt de compiler om een lidfunctie van dat object aan te roepen, omdat die lidfunctie eventueel de dataelementen van het object zou kunnen wijzigen. Echter zijn soms lidfuncties vereist die enkel de waarde van een data-element moeten teruggeven en die geen data-elementen wijzigen. Een dergelijke functie wordt gedeclareerd als const. Voorbeeld: class Datum { public: Datum(int Eendag, int Eenmaand, int Eenjaar); //constructor int GeefDag() const;

// read-only functie

int GeefMaand() const;


int GeefJaar() const;


void ZetMaand(int Eendag); void ZetMaand(int EenMaand); void ZetJaar(int EenJaar); void Toondatum() const; ~Datum(); private: int dag, maand, jaar; }; inline int Datum::GeefDag() const { return dag; }


60

In het beschouwde voorbeeld staat na elke functie die de inhoud van het object datum leest, het sleutelwoord const. Op die manier is het toch mogelijk die lidfuncties aan te roepen, zoals in volgend voorbeeld: int i; const datum Geboortedatum(21, 7, 1970); i= Geboortedatum.GeefDag(); Geboortedatum.ZetJaar(1985);

//fout: ZetJaar niet constant

2.8 Objecten als functiewaarde In het programma P148.cpp wordt de som van de inhoud van de twee spaarbussen gemaakt door de objecten bus1 en bus2 te gebruiken als argumenten van de lidfunctie som(), nl. totaal.som(bus1, bus2). Die som kan ook worden berekend door een lidfunctie, die een object aflevert met als inhoud de som. De oproep van die functie kan als volgt: totaal = bus1.som(bus2); Betekenis: stuur aan het object bus1 het bericht om de som te berekenen van zijn eigen inhoud en van de inhoud van bus2, en lever het resultaat af als functiewaarde. De lidfunctie som() heeft één argument (bus2) van het type Spaarbus, en levert een object af van datzelfde type. De declaratie van som() is dus: Spaarbus som(Spaarbus b); Echter, opdat som() een object zou kunnen afleveren, moet dat object eerst gemaakt worden. Daartoe is in de lidfunctie som() de declaratie van dat object vereist. Dat object heeft als taak de uitgerekende waarden in zich op te bergen en vervolgens af te leveren. Zo’n tijdelijk object (tempory object) wordt veelal temp genoemd, doch de aanduiding met ‘hulp’ is ook geschikt. De definitie van de lidfunctie som() wordt dus: Spaarbus Spaarbus::som(Spaarbus b) { Spaarbus temp; temp.éénEuro= éénEuro + b.éénEuro; temp.tweeEuro= tweeEuro + b.tweeEuro; temp.bereken(); return temp; } Spaarbus Spaarbus::som(Spaarbus b) De eerste Spaarbus geeft het type aan van de functiewaarde. De tweede Spaarbus geeft aan bij welke klasse de functie hoort. Bij aanroep van de functie som() met totaal= bus1.som(bus2) wordt de inhoud van bus2 gekopieerd naar het value-argument b. De regel temp.éénEuro= éénEuro + b.éénEuro;


61

moet als volgt worden gelezen: tel het aantal stukken van éénEuro van bus1 op bij die van bus2 en berg de som op in temp.éénEuro. Het volledige programma is als volgt: /* programma P149.cpp */ #include class Spaarbus { private: int éénEuro, tweeEuro, totaal; public: // constructor met default argumenten Spaarbus(int stuk1= 0, int stuk2= 0) { éénEuro= stuk1; tweeEuro= stuk2; bereken(); } // overige lidfuncties Spaarbus som(Spaarbus b); void bereken(); void print(); }; Spaarbus Spaarbus::som(Spaarbus b) { Spaarbus temp; temp.éénEuro= éénEuro + b.éénEuro; temp.tweeEuro= tweeEuro + b.tweeEuro; temp.bereken(); return temp; } void Spaarbus::bereken() { totaal= éénEuro * 1 + tweeEuro * 2; } void Spaarbus::print() { cout<<”totaal aantal stukken van éénEuro: “<<éénEuro<<endl; cout<<”totaal aantal stukken van tweeEuro: “<
62

2.9 Object als referentie argument We weten hoe een object kan optreden als een ‘const reference argument’ van een functie. Die functie kan dan de inhoud van het betreffende object niet wijzigen. Door een referentie argument te gebruiken zonder const kan die functie wel de waarde van de leden van het object wijzigen. Voorbeeld: Stel dat de inhoud van twee spaarbussen moet gestopt worden in een derde spaarbus. De eerste twee spaarbussen komen dus leeg. Het programma is als volgt: /* programma P150.cpp */ #include class Spaarbus { private: int éénEuro, tweeEuro, totaal; void ledigen();

// private lidfunctie

public: Spaarbus(int stuk1= 0, int stuk2= 0) { éénEuro= stuk1; tweeEuro= stuk2; bereken(); } void opbergen(Spaarbus &b1, Spaarbus &b2); void bereken(); void print() const;

// const lidfunctie

}; void Spaarbus::opbergen(Spaarbus &b1, Spaarbus &b2) { éénEuro= b1.éénEuro + b2.éénEuro; tweeEuro= b1.tweeEuro + b2.tweeEuro; bereken(); b1.ledigen(); b2.ledigen(); } void Spaarbus::ledigen() { éénEuro= 0; tweeEuro= 0; bereken(); } void Spaarbus::print() const { cout<<”totaal aantal stukken van éénEuro: “<<éénEuro<<endl; cout<<”totaal aantal stukken van tweeEuro: “<
63

void Spaarbus::bereken() { totaal= éénEuro * 1 + tweeEuro * 2; } void main() { Spaarbus bus1(15, 10), bus2(10, 20), bus3; bus3.opbergen(bus1, bus2); bus1.print(); bus2.print(); bus3.print(); } •

Bespreking van de lidfunctie opbergen(). De referentie argumenten van opbergen() zorgen ervoor dat de argumenten b1 en b2 een alias worden voor bus1 en bus2. De functie opbergen() maakt gebruik van andere lidfuncties. Merk op dat voor bereken() geen object staat en dat de beide aanroepen van ledigen() worden voorafgegaan door een object. Op welk object wordt bereken() toegepast? Op het object waarop de functie opbergen() wordt toegepast en dit is bus3. De programmalijnen bereken(); b1.ledigen(); b2.ledigen(); moeten dus als volgt worden geïnterpreteerd: bus3.bereken(); bus1.ledigen(); bus2.ledigen();

•

Bespreking van de lidfunctie ledigen(). De lidfunctie ledigen() is privaat gedeclareerd in de klasse Spaarbus. Dit betekent dat ledigen() enkel kan worden opgeroepen door lidfuncties van dezelfde klasse als van ledigen(), hier van de klasse Spaarbus. Hoewel private lidfuncties minder worden gebruikt dan private data-elementen, kan er soms toch een goede reden zijn om een lidfunctie privaat te declareren. In het beschouwde programmavoorbeeld is het leeg maken van een spaarbus een dermate ingrijpende handeling dat deze voorbehouden wordt aan een private lidfunctie. Op die manier wordt voorkomen dat vanuit een willekeurige plaats in het programma een bus geledigd kan worden.

•

Bespreking van void print() const. Const achter de functienaam print() betekent dat de functie print() het object waarmee hij wordt aangeroepen, bijvoorbeeld bus1.print(), niet kan wijzigen. Met andere woorden, bij volgende oproep: bus1.print(); is het object bus1 een constante voor de lidfunctie print(). Wanneer print() toch zou pogen bus1 te wijzigen, zal een foutmelding optreden.

64

Merk op dat const niet alleen in de declaratie van de lidfunctie print() moet staan, maar ook in de definitie van print().

2.10 Oefeningen 1) Schrijf een programma dat gebruik maakt van de klasse Getal. De klasse Getal bevat het private data-element g van het type int, en de publieke lidfuncties print() en invoer(). De gebruiker kan een waarde ingeven voor g en de uitvoer is als volgt: ingevoerde waarde: 10 g = 10 2) Schrijf een programma dat gebruik maakt van de klasse Getallenreeks. De gebruiker moet vijf getallen invoeren. Het programma toont de ingevoerde getallen, de gemiddelde waarde van die vijf getallen en de maximale waarde. Gebruik voor elke handeling een lidfunctie: invoer(), tonen(), gemiddelde() en maximum(). 3) Schrijf een programma dat gebruik maakt van de klasse Rechthoek. De gebruiker moet hoogte en breedte kunnen invoeren. Het programma berekent de omtrek en de oppervlakte van de rechthoek. Gebruik een lidfunctie voor de invoer, voor de berekening van de omtrek, voor de berekening van de oppervlakte en voor het tonen van de resultaten. 4) Schrijf een programma dat gebruik maakt van de klasse Spaarbus. De gebruiker moet het aantal stukken van éénEuro en van tweeEuro voor twee bussen kunnen invoeren. Het programma toont het aantal stukken van elke bus. Gebruik een lidfunctie voor het vullen van de spaarbussen en voor het tonen van de inhoud van de spaarbussen.

3. Conversie, klassen en operatoren 3.1 Algemeen Voor de standaardtypes (char, int, long, double) en voor de pointers bezit C++ volgende voorzieningen: 1) de operatoren +, -, * en /, die bewerkingen uitvoeren met waarden van de standaardtypes; 2) indien nodig, de conversie van het ene naar het andere type. Conversie kan automatisch gebeuren, zoals in double getal= 3;

//conversie van int 3 naar double 3.00

of kan afgedwongen worden met type-casting, zoals in double deling= double (11)/2; // resultaat: deling= 11.5 i.p.v. 11 Voor zelfgedefinieerde klassen bezit C++ bovenstaande voorzieningen niet. Wel kan de programmeur die voorzieningen creëren via: 1) operator overloading (= meervoudig gebruik van operatoren). Dit betekent dat de programmeur een nieuwe betekenis kan geven aan standaard operatoren, zodat die operatoren ook met objecten kunnen werken.


65

Zo’n overloaden operator (overladen operator) behoudt wel zijn oorspronkelijke betekenis. Afhankelijk van de operanden (= de waarden waarop de operator werkt) zal de compiler voor de standaard of voor de nieuwe betekenis kiezen. Operator overloading biedt het voordeel dat bewerkingen met objecten op een natuurlijke wijze kunnen worden genoteerd. Dit maakt programma’s beter leesbaar en begrijpbaar. 2) zelf definiëren van de conversie van een standaardtype naar een klassetype of omgekeerd. Constructoren spelen hierbij een belangrijke rol.

3.2 De copy constructor 3.2.1 Algemeen De copy constructor wordt aangewend om een object x van een klasse gelijk te stellen aan een object y van diezelfde klasse. In volgend voorbeeld wordt het object y van klasse T gelijkgesteld aan het object x van klasse T. class T { private: int i, j; public: T(T& x1) { i= x1.i; j= x1.j; }; }; void main() } T x; T y(x); //kan in bepaalde gevallen ook: T y= x; (zie merk op) … } In bovenstaand voorbeeld is de copy constructor T(T&) voorzien. De opdracht T y(x) roept de copy constructor op. Een copy constructor heeft als enig argument de referentie naar de klasse waartoe hij behoort, in het voorbeeld de referentie T&. In het algemeen geldt dat, als T de naam is van een klasse, dan de copy constructor T(T&) zorgt voor de initialisatie van een object van dezelfde klasse T, m.a.w. de copy constructor zorgt voor het maken van een correcte kopie. Een copy constructor wordt gebruikt in elke situatie waar een object moet worden gelijk gemaakt aan een ander object van dezelfde klassen.

66

Dit is in volgende gevallen: •

Initialisatie van een nieuw object met een bestaand object.

•

Een ‘call by value’ aanroep van een functie. De parameter van de aangeroepen functie wordt geïnitialiseerd met het object dat wordt doorgegeven naar die functie.

•

Een functie geeft als returnwaarde een object (klasse-variabele) terug.

Merk op. Alhoewel de notatie T y= 10; lijkt op een toekenning, is het geenzins een toekenning. Een dergelijke notatie kan enkel met behulp van constructoren met één argument. In het voorbeeld van T y= 10; gaat de compiler op zoek naar een constructor met één argument van het type int. Dat argument krijgt de waarde 10 en dan pas wordt de constructor uitgevoerd om het object te maken. Een constructor met één argument zorgt voor de conversie van een standaardtype (in het voorbeeld: int) naar een klassetype (in het voorbeeld: T).

3.2.2 Programmavoorbeeld In volgend programma wordt het object t gelijk gesteld (geïnitialiseerd) met het object s met behulp van de copy constructor String(String&). /* programma P151.cpp */ #include #include<string.h> class String { private: char *p; int len; public: String(const char *ps)

// constructor1

{ p= new char[(len= strlen(ps))+1]; strcpy(p, ps); } String(String& str)

// copy constructor

{ p= new char[(len= str.len)+1]; strcpy(p, str.p); } void print() const { if (p) cout<

67

void main() { String s(“Een string implementatie”); String t(s);

//aanroep constructor1

// nu wordt de copy constructor gebruikt

cout<<”Inhoud van s = “; s.print(); cout<<”Inhoud van t = “; t.print(); }

3.2.3 Default copy constructor Door verschillende constructoren te definiëren met argumenten van verschillend type of met een verschillend aantal argumenten, creëert de programmeur een gereedschap (E: tool) dat flexibel inzetbaar is. In volgend voorbeeld worden vijf objecten (p1 tot en met p5) gedeclareerd, die elk met een andere constructor worden geïnitialiseerd. /* programma P152.cpp */ #include #include<string.h> class Personeel { private: char naam[40]; int volgnummer; public: Personeel()


{ strcpy(naam, “geen naam”); volgnummer = 0; } // constructor met één argument van het type char* Personeel(char *n) { strcpy(naam, n); volgnummer = 0; } // constructor met één argument van het type int Personeel(int nr) { strcpy(naam, “geen naam”); volgnummer = nr; } // constructor met twee argumenten Personeel(char *n, int nr) { strcpy(naam, n); volgnummer = nr; }

68

void print() const { cout<
3.3 Constructoren en conversie 3.3.1 De conversie constructor De conversie constructor is een constructor die een object van een bepaald type converteert naar een object van een ander type. In volgend programma is de conversie constructor Complex(int i) gedefinieerd en zijn in de functie main() de objecten c1 en c2 gedeclareerd van het type Complex en geïnitialiseerd met respectievelijk de waarden 4 en 2.


69

Alhoewel het normaal gezien niet mogelijk is om aan het complexe getal c enkel een int-waarde toe te kennen, kan dit toch met behulp van de conversie constructor Complex(int i). De compiler herkent de code c1= 4 als een conversie van een int naar een object van het type Complex, en zoekt in de klassedefinitie naar een conversie constructor, die dan de conversie maakt. De code c2(2) roept expliciet de conversie constructor op. /* programma P153.cpp */ #include class Complex { public: int a, b; Complex(int i)

// conversie constructor

{ a= i; b= 0; } }; void main(à { Complex c1= 4, c2(2); cout<<”complex getal c1 = (“<
3.3.2 Conversie door een constructor met default argumenten In het deel ‘Algemeen’ van de copy constructor (zie 3.2.1) hebben we geleerd dat een constructor met één argument zorgt voor de conversie van een standaardtype naar een klassetype. Behalve een constructor met één argument, kan ook een constructor met default argumenten zo’n conversie uitvoeren, op voorwaarde dat het mogelijk is die constructor aan te roepen met één argument van het bewuste standaardtype. Dit gebeurt in het volgend programma in de regel: Personeel(char *n, int nr= 0); Het programma maakt gebruik van de zelf geschreven copy constructor Personeel(Personeel &p). Deze definitie heeft enkel als doel om met de cout-opdracht duidelijk te tonen wanneer de copy constructor wordt geactiveerd. Anders heeft hier de zelf gedefinieerde copy constructor weinig zin, omdat hij eigenlijk precies hetzelfde werk doet als de default copy constructor, nl. het kopiëren van de inhoud van het ene object (het argument) naar het andere object (het nieuw te maken object).

70

We weten dat de compiler automatisch een default copy constructor genereert bij afwezigheid van een zelf gedefinieerde copy constructor. Toch zijn er situaties waarin het wel degelijk zinvol is om zelf een copy constructor te definiëren (zie verder). /* programma P154.cpp */ #include #include<string.h> class Personeel { private: char naam[40]; int volgnummer; public: Personeel(char *n, int nr= 0) { strcpy(naam, n); volgnummer = nr; cout<<”char* constructor”<endl; } Personeel(int nr) { strcpy(naam, “geen naam”); volgnummer = nr; cout<<”int constructor”<endl; } Personeel(Personeel &p) { strcpy(naam, p.naam); volgnummer = p.volgnummer; cout<<”copy constructor”<endl; } void print() const { cout<

71

De output van het programma is: De drie initialisaties: char* constructor int constructor copy constructor De drie objecten: 0, Els 5, geen naam 5, geen naam Bespreking van het programma: 1) Bij de initialisatie p1=”Els” zoekt de compiler een conversie die een string omzet naar een Personeel. Dit is de char* constructor, waarvan het tweede argument een default argument is. 2) Bij de initialisatie p2=5 zoekt de compiler een conversie die een int omzet naar een Personeel. Dit is de int constructor. 3) Bij de initialisatie p3=p2 zoekt de compiler een conversie die een Personeel kopieert naar een Personeel. Dit is de copy constructor.

3.3.3 Voorwaardelijke compilatie Voorwaardelijk compileren betekent dat opdrachten slechts worden gecompileerd als voldaan is aan een voorwaarde. Voorwaardelijk compileren gebeurt met de preprocessor-opdrachten #ifdef en #endif. De voorwaarde is dat de identifier, die staat achter #ifdef, is gedefinieerd met #define. Voorbeeld: #define LaatZien // . . . #ifdef LaatZien cout<<”constructor zonder argumenten”<<endl; #endif Met #define LaatZien wordt de opdracht tussen #ifdef LaatZien en #endif gecompileerd en kan worden uitgevoerd. Er mogen meerdere opdrachten worden geplaatst. Zonder #define LaatZien worden alle opdrachten tussen #ifdef LaatZien en #endif tijdens de compilatie genegeerd.

3.3.4 Conversie na de initialisatie In de vorige programmavoorbeelden worden de constructoren aangewend bij de declaratie en initialisatie van objecten. Initialisatie is de belangrijkste taak van een constructor. Een constructor kan ook na de initialisatie van een object nuttig zijn.

72

Volgend programma maakt gebruik van constructoren na de declaratie. Ook is voorwaardelijke compilatie toegepast. /* programma P155.cpp */ #include #include<string.h> #define LaatZien class Personeel { private: char naam[40]; int volgnummer; public: Personeel() { strcpy(naam, “geen naam”); volgnummer = 0; #ifdef LaatZien cout<<”default constructor”<endl; #endif } Personeel(char *n, int nr= 0) { strcpy(naam, n); volgnummer = nr; #ifdef LaatZien cout<<”char* constructor”<endl; #endif } Personeel(int nr) { strcpy(naam, “geen naam”); volgnummer = nr; #ifdef LaatZien cout<<”int constructor”<endl; #endif } Personeel(const Personeel &p) { strcpy(naam, p.naam); volgnummer = p.volgnummer; #ifdef LaatZien cout<<”copy constructor”<endl; #endif } void print() const { cout<
73

void main() { Personeel p1, p2, p3; p1= 5; p2= “Els”; p3= p2; cout<<endl; cout<<”De drie objecten: “<<endl; p1.print(); p2.print(); p3.print(); } De output van het programma is: default constructor default constructor default constructor int constuctor char* constructor De drie objecten: 5, geen naam 0, Els 0, Els Bespreking van het programma: 1) De copy constructor Personeel(const Personeel &p) moet worden aangeroepen met een argument dat een object is van de klasse Personeel. De referentie &p zorgt voor een efficiënte functie-aanroep en const zorgt ervoor dat het originele object niet kan gewijzigd worden. 2) De default constructor (de constructor zonder argumenten) wordt aangeroepen voor de objecten p1, p2 en p3. Die objecten worden dus geïnitialiseerd met de string “geen naam” en met volgnummer 0. 3) De int constructor wordt aangeroepen door het statement p1= 5. Omdat p1 reeds een bestaand object is, moet eigenlijk voor p1 geen constructor meer aan het werk gaan. Dat toch de int-constructor gebruikt wordt, komt door het feit dat de compiler op zoek gaat naar een constructor die het int-getal 5 wil converteren naar Personeel. De compiler vindt een dergelijke constructor en roept die aan, nl. de int constructor. De int constructor maakt een tijdelijk en naamloos object aan met als volgnummer de waarde 5. Vervolgens wordt de inhoud van het tijdelijke object gekopieerd in p1. Dit gebeurt niet met de copy constructor, maar met de toekenningsoperator, die standaard bij elke klasse is geleverd. Na het kopiëren wordt het tijdelijke object vernietigd. 4) Bij uitvoering van de opdracht p2=5 gebeurt hetzelfde als bij p1=”Els”, doch nu met gebruik van de char* constructor om een tijdelijk object te maken. 5) Bij p3=p2 wordt de inhoud van p2 gewoon gekopieerd in p3 met behulp van de standaard toekenningsoperator.

74

3.3.5 Conversie met andere constructoren We weten dat een constructor met één argument van een standaardtype zorgt voor de conversie van dat standaardtype naar een klassetype. De beperking van één argument kan omzeild worden door een constructor expliciet aan te roepen. Voorbeeld: Stel de declaratie van volgend object: Personeel p1; . De constructor met twee argumenten, nl. Personeel(char *n, int nr) kan als volgt worden aangeroepen: p1= Personeel(“Rik”, 15); De constructor maakt dan een tijdelijk object met de naam “Rik” en volgnummer 15. Vervolgens wordt de inhoud van het tijdelijk object gekopieerd in p1 met behulp van de standaard toekenningsoperator. Dit mechanisme kan ook toegepast worden met andere constructoren: p1= Personeel(“Ria”); // char* constructor en standaard toekenning p1= Personeel();

// default constructor en standaard toekenning

3.4 Overzicht en samenvatting constructoren Constructoren zijn lidfuncties die een belangrijke rol spelen bij het maken en initialiseren van objecten. Een klasse X heeft een copy constructor X(const X&), die tot taak heeft een object te maken door er een te kopiëren. Door zelf constructoren te overloaden wordt het mogelijk een hele reeks conversiemogelijkheden te maken, die in heel wat situaties beschikbaar zijn, zowel tijdens de initialisatie van objecten als in toekenningsopdrachten. Initialisatie: gebruik van constructoren tijdens de declaratie Constructor met 0 argumenten: Personeel p; Personeel p= Personeel(); Constructor met 1 argument: Personeel p(“Els”); Personeel p=”Els”; Personeel p= Personeel(“Els”); Constructor met 2 argumenten: Personeel p(“Els”, 5); Personeel p= Personeel(“Els”, 5); Na de declaratie van een object y, waarbij bijvoorbeeld de default constructor is gebruikt en waarbij al of niet initialisatie is gebeurd, kan aan dat object y waarden worden gegeven met behulp van constructoren.


75

Toekenning: gebruik van constructoren na de declaratie. Constructor met 0 argumenten: y= Personeel(); Constructor met 1 argument: y= “Els”; y= Personeel(“Els”); Constructor met 2 argumenten: y= Personeel(“Els”, 5);

3.5 Operator overloading 3.5.1 Algemeen De taal C++ laat het gebruik toe van operator-functies. Een operator-functie laat de programmeur toe om bepaalde functies te schrijven in algebraïsche notatie, zoals bij het optellen van twee getallen: a + b . Het gebruik van de operator ‘+’ is conceptueel eenvoudiger en leesbaarder dan de functie optellen(int a, int b). In C zijn de operatoren, zoals +, -, *, /, standaard voorzien in de taal. In verband met klassen zijn in C++ slechts twee operatoren op objecten standaard gedefinieerd: de toekenningsoperator ‘=’ en de adres-van-operator ‘&’. De toekenningsoperator kopieert het ene object lid voor lid in het andere object. De adres-van-operator levert het adres op van het object. Daarentegen laat C++ toe om expliciet operatoren te definiëren die kunnen inwerken op reeds gedefinieerde klassen. Het is dus mogelijk om de operator ‘+’ te definiëren voor het optellen van twee getallen, die behoren tot een klasse. Dergelijke zelf gedefinieerde operatoren zijn volledig equivalent met gewone functies. Zelf gedefinieerde operatoren zijn gewoonweg een andere en soms betere notatie van een functie. Het is raadzaam enkel operatoren zelf te definiëren als ze een zinvolle betekenis hebben. In de taal C zijn bepaalde operatoren zoals +, -, *, /, gedefinieerd als overladen operatoren (E: overloaded operators). Dit betekent dat bijvoorbeeld de operator ‘+’ kan worden gebruikt voor het optellen van twee integers, maar ook kan worden gebruikt voor het optellen van twee floats. In C++ moet de programmeur zelf het overladen van operatoren definiëren.

3.5.2 Lidfunctie die de som berekent van twee objecten Volgend programma maakt gebruik van de klasse Voorraad, waarin de aantallen worden bijgehouden van kleine en grote artikelen. Verder bezit de klasse Voorraad de lidfunctie som(), die de som berekent van twee objecten van de klasse Voorraad.

76

/* programma P156.cpp */ #include class Voorraad { private: int klein, groot; public: Voorraad(int k=0, int g=0) { klein= k; groot= g; } Voorraad som(Voorraad); void print() const; }; Voorraad Voorraad::som(Voorraad v) { Voorraad hulp; hulp.klein= klein + v.klein; hulp.groot= groot + v.groot; return hulp; } void Voorraad::print() const { cout<

77

2) De lidfunctie som() wordt aangeroepen door totaal= v1.som(v2); Betekenis: stuur aan v1 de boodschap dat hij de som moet maken van zichzelf en van v2. Het resultaat, de functiewaarde dus, moet in totaal worden opgeslagen. Omdat de functiewaarde een object is met de leden klein en groot, waarvan eerst de waarde moet worden bepaald, is in de functie som() het object hulp gedeclareerd. De som wordt aldus als volgt berekend: hulp.klein = klein + v.klein; Omdat de functie som() is aangeroepen met v1.som(v2), moet vorige berekening als volgt worden gelezen: hulp.klein = v1.klein + v2.klein;

3.5.3 Tijdelijk object door een constructor laten maken In vorig programma is het object hulp gedeclareerd in de functie som(). In het object hulp worden een paar waarden opgeslagen. Die twee bewerkingen, namelijk -

het maken van het object hulp

-

en het opbergen van waarden in het object hulp,

zijn eigenlijk typisch werk voor een constructor. En de klasse Voorraad heeft hiervoor een geschikte constructor. Die constructor moet alleen worden opgeroepen met de juiste waarden voor de elementen, namelijk als volgt: Voorraad(klein + v.klein, groot + v.groot); Hiermee wordt een object gemaakt, dat de som bevat van de twee voorraden. Dit is precies het object dat som() als functiewaarde moet afleveren. Daarom is volgende definitie van som() beter: Voorraad Voorraad::som(Voorraad v) { return Voorraad(klein + v.klein, groot + v.groot) } Het is beter gebruik te maken van een constructor wanneer een tijdelijk object nodig is. Het vorig programma wordt dus: /* programma P157.cpp */ #include class Voorraad { private: int klein, groot; public:

78

Voorraad(int k=0, int g=0) { klein= k; groot= g; } Voorraad som(Voorraad); void print() const; }; Voorraad Voorraad::som(Voorraad v) { return Voorraad(klein + v.klein, groot + v.groot); } void Voorraad::print() const { cout<
3.5.4 De operator + in plaats van de somfunctie In vorig programma wordt de lidfunctie som() als volgt aangeroepen: totaal = v1.som(v2); Hierbij zijn drie objecten betrokken: v1, v2 en totaal. De notatie totaal = v1 + v2; is mogelijk door de naam ‘som’ te vervangen door ‘operator +’. Dus ‘Voorraad som(Voorraad)’ wordt ‘Voorraad operator+(Voorraad)’ en ‘totaal= v1.som(v2)’ wordt ‘totaal= v1.operator+(v2)’. De ‘operator+’ is een voorbeeld van operator-functie, namelijk een operator die als functie genoteerd wordt: operator+(). Nu mag de notatie ‘operator+()’ worden vervangen door het +teken, dus: v1.operator+(v2) wordt v1 + v2. Het programma met de operator-functie operator+() is als volgt:


79

/* programma P158.cpp */ #include class Voorraad { private: int klein, groot; public: Voorraad(int k=0, int g=0) { klein= k; groot= g; } Voorraad::operator+(Voorraad v) { return Voorraad(klein + v.klein, groot + v.groot); } void print() const; }; void Voorraad::print() const { cout<
3.5.5 Operatoren voor overloading Enkel bestaande operatoren kunnen overladen worden, dit is een nieuwe betekenis geven aan de operator. Volgende operatoren kunnen worden overladen: +

-

*

/

%

^

&

|

~

!

=

<

>

+=

-=

*=

/=

%=

^=

&=

|=

<<

>>

>>=

<<=

==

!=

<=

>=

&&

||

++

--

.

->*

->

()

[]

new

delete

80

Voor de overladen operatoren gelden volgende zaken zoals voor de originele operatoren: -

de prioriteit

-

de associativiteit

-

de ronde haakjes

-

het aantal operanden

Volgende operatoren kunnen zowel met één operand als met twee operanden voorkomen: +, -, * en &. Het overladen van een operator met één operand vereist een operator-functie zonder argument. Voorbeeld: Voorraad operator-() { return Voorraad(-klein, -groot); } De return-opdracht maakt gebruik van de constructor van de klasse Voorraad. Een operator met twee operanden krijgt een operator-functie met één argument. Voorbeeld: Voorraad operator+(Voorraad v) { return Voorraad(klein + v.klein, groot + v.groot); }

3.5.6 De this-pointer 3.5.6.1 De this-pointer Bij aanroep van een lidfunctie levert C++ automatisch een pointer op naar het object waarmee de functie wordt aangeroepen. Deze pointer heet altijd ‘this’. De this-pointer is in elke lidfunctie, dus ook in de operator-functies, te gebruiken. Voorbeelden: •

Bij aanroep van de lidfunctie print() met x.print(), waarbij x een object is, zal de pointer this wijzen naar het object x.

•

Bij aanroep van de lidfunctie som(y) via de opdracht x.som(y), zal de thispointer wijzen naar x.

•

Bij aanroep van de operator-functie operator+=() via de opdracht x+=y, zal de pointer this wijzen naar x.

Als de this-pointer wijst naar een object, dan is uiteraard de uitdrukking *this dat object zelf. Dus kan *this gebruikt worden wanneer de operator-functie een object als functiewaarde moet opleveren.


81

Voorbeeld: Voorraad& operator+=(Voorraad v) { klein += v.klein; groot += v.groot; return *this;

// gebruik van de this-pointer

}

3.5.6.2 Overladen van een assignment-operator De this-pointer is nodig om een toekenningsoperator zoals += correct te kunnen overladen, namelijk dat de zelf gedefinieerde operator += (operator-functie) volledig het gedrag van de originele operator += nabootst. Voorbeeld: Voorraad& operator+=(Voorraad v) { klein += v.klein; groot += v.groot; return *this; } Merk op dat Voorraad& een ‘return by reference’ moet zijn. Immers, met een ‘return by value’, zoals in volgende definitie: Voorraad operator+=(Voorraad v)

// zonder &

{ klein += v.klein; groot += v.groot; return *this; } wordt er een tijdelijk object aangemaakt dat geïnitialiseerd wordt met het object dat achter return staat. Voor deze initialisatie zorgt de copy constructor. Voorbeeld: Voorraad v1(8, 15), v2(5, 7), v3(6, 2); (v1 += v2) += v3; De uitdrukking (v1 += v2) levert een tijdelijk object af dat wel dezelfde inhoud heeft als het object v1, maar niet het object v1 is. Met (v1 += v2) += v3 wordt vervolgens bij dat tijdelijk object de inhoud van v3 opgeteld. Daarna gaat het tijdelijk object verloren. Dit betekent dat de uitdrukking (v1 += v2) += v3 enkel als resultaat geeft dat de inhoud van v1 is vermeerderd met de inhoud van v2, maar daarmee is het ook gedaan. Met gebruik van ‘return by reference’ wordt de uitdrukking (v1 += v2) in zijn geheel een alias voor v1. Dit betekent dat in de uitdrukking (v1 += v2) += v3 eerst v2 wordt opgeteld bij v1 en dat vervolgens bij v1 de inhoud van v3 wordt opgeteld.

82

3.6 Friend operatoren 3.6.1 Friend De C++ compiler weigert toegang tot klasse-elementen die ‘private’ of ‘protected’ zijn gedeclareerd. Deze stricte regel zorgt soms voor problemen wanneer gewone procedures private elementen van een bepaalde klasse nodig hebben. Wanneer deze situatie zich voordoet, kan de programmeur gebruik maken van het concept ‘friend’. Friend laat toe om een gecontroleerde toegang mogelijk te maken tot de private elementen van een klasse. Een procedure die gebruik wil maken van de private elementen van een klasse, wordt als friend gedeclareerd in die klasse. Voorbeeld: class X { friend int ToegangPriveElement(void); friend class Y; private: int PriveElement; }; De procedure ToegangPriveElement() is gedeclareerd als een friend zodat ze toegang krijgt tot het privaat data-element PriveElement. Naast gewone procedures, kunnen ook lidfuncties van een andere klasse en zelfs een volledige klasse (zie class Y in het voorbeeld) als friend gedeclareerd worden. Wanneer een klasse als friend gedeclareerd wordt, dan zijn alle leden van die klasse friends van de andere klasse.

3.6.2 Probleem Volgend programma maakt de vermenigvuldiging van de inhoud van de klasse Voorraad met de int-waarde 4, zonder gebruik van de friend-operator. Het probleem is dat ‘resultaat= 4 * v’ niet kan. /* programma P159.cpp */ #include class Voorraad { private: int klein, groot; public: Voorraad(int k=0, int g=0) { klein= k; groot= g; }


83

Voorraad operator*(int i);

// operator*()

{ return Voorraad(klein * i, groot * i); } void print() const; }; void Voorraad::print() const { cout<
3.6.3 De friend operator De friend operator is geen lid van een klasse, maar een operator die als ‘bevriende’ operator van de klasse wordt gedefinieerd. Bevriend wil zeggen dat de operator toegang krijgt tot de private leden van de klasse. De friend operator*() met als taak een int-waarde te vermenigvuldigen met een Voorraad, heeft twee argumenten: 1) het eerste argument is van het type int 2) het tweede argument is van het type Voorraad. Dus:

friend Voorraad operator*(int i, Voorraad v) { return Voorraad(i * v.klein, i * v.groot); }

84

Met de friend operator*() wordt de uitdrukking resultaat= 4 * v; geïnterpreteerd als operator*(4, v), dus als een operator met twee argumenten. Volgend programma maakt de vermenigvuldiging van de inhoud van de klasse Voorraad met de int-waarde 4, met gebruik van de friend operator*(), zodat de uitdrukkingen res1 = v * 4; en

res2 = 4 * v;

beide mogelijk zijn. /* programma P160.cpp */ #include class Voorraad { private: int klein, groot; public: Voorraad(int k=0, int g=0) { klein= k; groot= g; } // operator*() als lid Voorraad operator*(int i); { return Voorraad(klein * i, groot * i); } // operator*() als friend friend Voorraad operator*(int i, Voorraad v); { return Voorraad(i * v.klein, i * v.groot); } void print() const { cout<
85

Meestal is een friend operator nodig als de operator een operand heeft van een standaardtype zoals int, long, double of char*.

3.7 Conversie van een klasse naar een standaardtype 3.7.1 De conversie-functie We weten reeds hoe met behulp van constructoren een conversie wordt gerealiseerd van een standaardtype naar een klassetype. Voor de conversie van een klasse naar een standaardtype moet een speciale conversie-functie geschreven worden. Voorbeeld: class Personeel { private: char naam[40]; int volgnummer; public: // . . . //declaratie in de klasse Personeel van de conversie-functie voor //conversie van een object Personeel naar een string, dus conversie //naar het standaardtype char*: operator char*() { return naam; } //declaratie in de klasse Personeel van de conversie-functie voor //conversie van een object Personeel naar een int: operator int() { return volgnummer; } //. . . }; Een conversie-functie heeft de naam van het standaardtype waar hij naar converteert, voorafgegaan door het woord operator. Een conversie-functie heeft nooit argumenten en heeft nooit een return-type. De naam van de functie geeft eigenlijk het return-type reeds aan. Volgend programma maakt gebruik van conversie van een klasse naar standaardtype. /* programma P161.cpp */ #include #include<string.h>

86

class Personeel { private: char naam[40]; int volgnummer; public: Personeel(char *n=”geen naam”, int nr= 0) { strcpy(naam, n); volgnummer = nr; } operator char*() {return naam;} operator int() {return volgnummer;} void print() const { cout<
6

Els en Rik

3.7.2 Impliciete en expliciete aanroep van een conversie-functie Bij uitvoering van strcpy(str, p1); zoekt de compiler naar een mogelijkheid om het object p1 om te zetten naar een char*. De compiler vindt die in de conversie-functie operator char*. Op die manier wordt de conversie-functie impliciet aangeroepen. Een expliciete aanroep is als volgt: strcpy(str, (char*) p1);


87

3.8 Conversie tussen klassen Volgend programma maakt de conversie van de klasse Lid naar de klasse Bestuurslid en omgekeerd. /* programma P162.cpp */ #include #include<string.h> class Bestuurslid;

//declaratie van de naam van de klasse

class Lid { private: char lidnaam[40]; int lidnummer; public: Lid(char*, int); operator Bestuurslid(); //declaratie van de naam van de operator void print() const; }; class Bestuurslid

//definitie van de klasse

{ private: char bestuurslidnaam[40]; int bestuurslidnummer; public: Bestuurslid(char*, int); operator Lid(); void print() const; }; Lid::operator Bestuurslid()

//definitie van de operator

{ return Bestuurslid(lidnaam, lidnummer); } Lid::Lid(char* naam= “geen naam”, int nr= 0) { strcpy(lidnaam, naam); lidnummer= nr; } void Lid::print() { cout<
88

Bestuurslid::Bestuurslid(char* naam= “geen naam”, int nr= 0) { strcpy(bestuurslidnaam, naam); bestuurslidnummer= nr; } Bestuurslid::operator Lid() { return Lid(bestuurslidnaam, bestuurslidnummer); } void Bestuurslid::print() { cout<
//conversie van lid naar bestuurslid

cout<<”Het bestuur: “<<endl; b1.print(); b2.print(); Lid ld3 = b2;

//conversie van bestuurslid naar lid

cout<<”De leden: “<<endl; ld1.print(); ld2.print(); ld3.print(); } De output van het programma is: Het bestuur: 6, Rik 8, Ria De leden: 5, Els 6, Rik 8, Ria Bespreking van het programma: 1) Voor b1=ld2 is de conversie van Lid naar Bestuurslid nodig. Dit kan gerealiseerd worden met een conversie-functie in de vorm van een operator, die als lidfunctie van de klasse Lid wordt gedeclareerd: operator Bestuurslid() { return Bestuurslid(lidnaam, lidnummer); }


89

Deze operator converteert wel een Lid naar Bestuurslid, doch de compiler, die de tekst van het programma van boven naar beneden leest, kent de klasse Bestuurslid nog niet op het moment dat hij bij de klasse Lid is. Dit probleem wordt opgelost door vóór de definitie van de klasse Lid de declaratie van de klasse Bestuurslid te plaatsen. Dit bebeurt met: class Bestuurslid; . De compiler neemt kennis van de naam Bestuurslid en rekent erop dat de definitie van de klasse Bestuurslid verderop in het programma staat. 2) In de conversie-functie operator Bestuurslid() { return Bestuurslid(lidnaam, lidnummer); } wordt gebruik gemaakt van de constructor van de klasse Bestuurslid, en deze constructor wordt pas verderop gedefinieerd. Dit probleem wordt opgelost door in de klasse Lid enkel de declaratie van de conversie-functie, nl. operator Bestuurslid(), op te nemen, en de definitie van de conversie-functie, waarin de aanroep van de constructor staat, na de definitie van alle klassen te plaatsen. Buiten de klassen doet de volgorde van de lidfuncties er niet toe, omdat de compiler in eerste instantie afgaat op de declaraties.

3.9 Oefeningen 1) Schrijf een programma met een klasse voor een voertuig. De klasse bevat de data-elementen ‘soort voertuig’ en ‘aantal wielen’. Het programma moet vier verschillende constructoren bevatten, evenals de declaratie van acht objecten, waarvoor zowel bij initialisatie als bij toekenningen, diverse constructoren worden gebruikt. Voorzie de output van het programma met commentaar. 2) Schrijf een programma dat gebruik maakt van de objecten X, Y en Z van de klasse Voorraad, waarin de aantallen worden bijgehouden van de kleine en grote artikelen. Het programma moet volgende bewerkingen kunnen verrichten:

A = B – C; A = B * 1.5;

3) Schrijf een programma dat gebruik maakt van de klasse Tijd, die de int-leden uur, minuten en seconden bevat. Het programma moet twee tijden kunnen optellen (t3 = t1 + t2) en moet de berekening t1 += t2 (betekenis: t1 = t1 + t2) kunnen uitvoeren met objecten van de klasse Tijd.

90

4. Overerving 4.1 Overerving (E: inheritance) 4.1.1 Basisklasse en afgeleide klasse De grote kracht van een OO-taal is de mogelijkheid om vanuit een bestaande klasse (genoemd de basisklasse, E: base class) een nieuwe klasse (genoemd de afgeleide klasse, E: derived class) af te leiden die een meer gespecialiseerde taak uitvoert dan de basisklasse. De afgeleide klasse erft alle eigenschappen van zijn basisklasse, en kan ook nog eigenschappen van zichzelf hebben. Onder ‘eigenschappen’ worden alle dataelementen en lidfuncties verstaan. Voorbeeld: De klasse Rechthoek is een afgeleide klasse van de klasse Veelhoek. Immers, een rechthoek is een speciale veelhoek, namelijk een veelhoek met vier rechte hoeken. De klasse Vierkant is een afgeleide klasse van de klasse Rechthoek. Immers, een vierkant is een speciale rechthoek, namelijk een rechthoek met gelijke lengte en breedte. Het voorbeeld toont aan dat een afgeleide klasse op haar beurt de basisklasse kan zijn van een andere klasse.

4.1.2 Doelstellingen van overerving Overerving heeft twee doelstellingen: 1) Overerving laat de programmeur toe om de hiërarchische natuur van veel problemen op een elegante manier te implementeren in de OO-taal. In die zin is overerving een middel om het concept van specialisatie te verwezenlijken. Het concept van specialisatie stopt de algemene aspecten van een probleem in een basisklasse en kent meer gespecialiseerde eigenschappen toe aan afgeleide klassen. 2) Overerving laat toe om bestaande klassen aan te passen aan eigen noden. Voorbeeld: Een bibliotheekfunctie voldoet niet altijd volledig aan de wensen van de programmeur. In C++ kan dit elegant opgelost worden door een nieuwe klasse te maken, afgeleid van de bestaande bibliotheekklasse en vervolgens aan deze nieuwe klasse bijkomende lidfuncties en/of data-elementen toe te voegen zodat de afgeleide klasse beantwoordt aan alle criteria die de programmeur beoogt.


91

4.2 De basisklasse Volgend programma maakt gebruik van de klasse Rechthoek, met als dataelementen ‘breedte’ en ‘hoogte’. Een constructor met default argumenten zorgt voor de constructie van het object R en de lidfunctie print() zet het object R op het scherm met behulp van sterretjes en spaties. /* programma P163.cpp */ #include class Rechthoek { private: int hoogte; int breedte; public: Rechthoek(int h= 1, int b= 1); void print(); }; Rechthoek::Rechthoek(int h, int b) { hoogte= h; breedte= b; } void Rechthoek::print() { for (int r= 0; r < hoogte; r++) { for (int k= 0; k < breedte; k++) cout<<”* “; cout<<endl; } } void main() { Rechthoek R(3,5); R.print(); cin.get(); } De output van het programma is: ***** ***** ***** Een voor-de-hand-liggende uitbreiding van bovenstaand programma is de mogelijkheid voor de gebruiker om de afmetingen van de rechthoek zelf te kunnen bepalen binnen bepaalde grenzen.

92

In plaats van de klasse Rechthoek te wijzigen met bijkomende lidfuncties, wordt de klasse Rechthoek beschouwd als de basisklasse en wordt van de klasse Rechthoek een afgeleide klasse gemaakt met daarin de nodige bijkomende lidfuncties.

4.3 Afgeleide klasse 4.3.1 Constructie van een afgeleide klasse Het construeren van een afgeleide klasse bestaat erin om bepaalde elementen aan een klasse toe te voegen en/of te wijzigen. Op die manier wordt de reeds bestaande code van de basisklasse herbruikt, maar wel aangepast aan de eisen opgelegd door de afgeleide klasse. De procedure voor het afleiden van een klasse B (Base class) bestaat erin een nieuwe klasse D (Derived class) als volgt te creëren: class D : public B { // declaratie van de D-leden }; Hiermee is een afgeleide klasse D gecreëerd die publiek afgeleid is van de klasse B. Met andere woorden, D is een afgeleide klasse van B, en B is de basisklasse van D, of nog: D erft van B. Het hele mechanisme heet overerving.

4.3.2 Geheugenlayout van een afgeleid object geheugen afgeleid object leden basisklasse unieke leden van de afgeleide klasse

In het geheugen vormen de leden, afkomstig van de basisklasse, het eerste deel van een afgeleid object. Het tweede deel van dat afgeleide object bevat de nieuwe leden. Uit de geheugenlayout van een afgeleid object kunnen we besluiten dat we altijd een afgeleide klasse kunnen gebruiken daar waar een basisklasse verwacht wordt. Immers, de afgeleide klasse bezit alle leden van de basisklasse. Dus, elke functie die inwerkt op een basisklasse, kan ook inwerken op de afgeleide klasse.


93

Uiteraard moet vóór de definitie van de afgeleide klasse D (zie procedure in 4.3.1) de compiler reeds de definitie van de klasse B gelezen hebben. Dit geldt ook voor de declaratie van een object behorend tot de klasse D.

4.3.3 Programmavoorbeeld /* programma P164.cpp */ #include const int KleinsteBreedte= 1, KleinsteHoogte= 1, GrootstBreedte= 39, GrootsteHoogte= 24; class Rechthoek

// basisklasse

{ protected:

// protected zodat de leden toegankelijk zijn

int hoogte;

// vanuit de afgeleide klasse

int breedte; public: Rechthoek(int h= KleinsteHoogte, int b= KleinsteBreedte); void print(); }; class FlexRechthoek : public Rechthoek

// afgeleide klasse

{ public: void breder(); void hoger(); }; // lidfuncties van Rechthoek Rechthoek::Rechthoek(int h, int b) { hoogte= h; breedte= b; } void Rechthoek::print() { for (int r= 0; r < hoogte; r++) { for (int k= 0; k < breedte; k++) cout<<”* “; cout<<endl; } } // lidfuncties van FlexRechthoek void FlexRechthoek :: breder() { if (breedte < GrootsteBreedte) breedte++; }

94

void FlexRechthoek :: hoger() { if (hoogte < GrootsteHoogte) hoogte++; } void main() { FlexRechthoek R; R.print(); cout<<endl; R.breder(); R.breder(); R.hoger(); R.print(); cin.get(); } De output van het programma is: * *** *** Merk op: 1) In de definitie van de basisklasse Rechthoek zijn de data-elementen ‘protected’ in plaats van ‘private’. Dit is om de data-elementen van de basisklasse toegankelijk te maken vanuit de afgeleide klasse FlexRechthoek. 2) De afgeleide klasse heeft geen eigen constructor. Toch wordt de opdracht ‘FlexRechhoek F’ correct uitgevoerd (zie verder). 3) De afgeleide klasse FlexRechthoek erft de lidfunctie print() van de basisklasse Rechthoek. De afgeleide klasse heeft dus zelf geen eigen functie print().

4.3.4 Private, public en protected Wat erft de afgeleide klasse FlexRechthoek in vorig programma precies? In principe alle leden van de basisklasse Rechthoek, behalve de constructor. Dit betekent echter niet dat objecten van de afgeleide klasse automatisch toegang hebben tot alle leden van de basisklasse. Vanuit de afgeleide klasse FlexRechthoek is er enkel toegang tot de publieke ( public) en tot de beschermde (protected) leden, niet tot de private (private) leden. Leden van een basisklasse die protected zijn, zijn wel toegangelijk vanuit afgeleide klassen, maar niet van buitenaf, bijvoorbeeld vanuit main().

4.3.5 Default-constructor van de basisklasse In bovenstaand programma heeft de afgeleide klasse FlexRechthoek geen constructor. Hoe kan dan toch een object van FlexRechthoek gemaakt worden met de opdracht FlexRechthoek R ? Eerst wordt de default-constructor van de basisklasse Rechthoek aangeroepen om een object van Rechthoek te maken. De default-constructor van Rechthoek zorgt er T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

95

dus voor dat de data-leden ‘hoogte’ en ‘breedte’ de waarde 1 krijgen. En FlexRechthoek erft deze leden met hun waarde. Omdat deze leden ‘protected’ zijn in de basisklasse, is hun toegankelijkheid in de afgeleide klasse gegarandeerd. Dat de default-constructor van de basisklasse wordt aangeroepen is te controleren door een cout-opdracht te plaatsen in de constructor, zoals volgt: Rechthoek::Rechthoek(int h, int b) { hoogte= h; breedte= b; cout<<”Default-constructor van de basisklasse.”<<endl; } Een default-constructor is een constructor zonder argumenten, of zoals in het beschouwde voorbeeld, een constructor die zonder argumenten kan worden aangeroepen omdat alle argumenten default-waarden hebben. De default-waarden staan in de declaratie, namelijk: Rechthoek(int h= KleinsteHoogte, int b= KleinsteBreedte); met KleinsteHoogte en KleinsteBreedte gedefinieerd als constanten met een waarde 1. Algemene regel: De regel is dat altijd eerst de default-constructor van de basisklasse wordt aangeroepen om een object van de basisklasse te maken. Pas daarna komt een eventuele aanwezige constructor van de afgeleide klasse aan de beurt.

4.3.6 Eigen constructor van een afgeleide klasse Omdat in vorig programma de afgeleide klasse FlexRechthoek geen eigen constructor heeft, is het niet mogelijk om het volgende te declareren: FlexRechthoek R(3, 4); . Immers, er is geen passende constructor. Van de basisklasse wordt enkel de default-constructor automatisch aangeroepen. Wel is het mogelijk om elke afgeleide klasse één of meer eigen constructoren te geven. Een geschikte constructor voor FlexRechthoek is: FlexRechthoek(int ht, int br) { hoogte= ht, breedte= br; }

4.3.7 Initializer Het werk dat de constructor van FlexRechthoek doet, kan ook gedaan worden door de constructor van de basisklasse, namelijk: Rechthoek(int h, int b) { hoogte= h, breedte= b; }

96

Daartoe moet de constructor van de basisklasse expliciet worden aangeroepen vanuit de afgeleide klasse, en wel als volgt: FlexRechthoek(int ht, int br) : Rechthoek(ht, br) {} De constructor van de basisklasse wordt aangeroepen vóór de accolades van de body van de constructor. Deze manier van aanroepen van de constructor van de basisklasse heet een ‘initializer’. In het opgegeven voorbeeld van initializer staat er niets tussen de accolades omdat er niets moet gedaan worden. In het algemeen kunnen tussen de accolades opdrachten geplaatst worden.

4.4 Functie-overriding 4.4.1 Functie-overriding In vorig programma zet de lidfunctie print() de rechthoek op het scherm met behulp van sterretjes en spaties. Om de rechthoek te kunnen opbouwen met een willekeurig teken (symbool), moet de afgeleide klasse FlexRechthoek uitgebreid worden met het data-element ‘symbool’, waarin het teken wordt opgeslagen waaruit de rechthoek moet worden opgebouwd. class FlexRechthoek : public Rechthoek { private: char symbool; public: // declaratie van de constructor voor FlexRechthoek FlexRechthoek(int ht, int br, char symb= ‘*’); void breder(); void hoger(); }; De constructor voor FlexRechthoek moet een deel van het werk zelf doen, en kan voor een deel terecht bij Rechthoek. De definitie van de constructor is als volgt: FlexRechhoek::FlexRechthoek(int ht, int br, char symb):Rechthoek(ht, br) { symbool= symb; } Omdat de functie print() van Rechthoek enkel sterretjes en spaties afdrukt, moet FlexRechthoek zijn eigen print-functie hebben. De print-functie van de basisklasse wordt daarmee overridden.


97

De print-functie van FlexRechthoek is als volgt: void FlexRechthoek::print() { for (int r= 0; r < hoogte; r++) { for (int k= 0; k < breedte; k++) cout<<symbool<<’ ‘; cout<<endl; } }

4.4.2 Programma met overriding van de print-functie /* programma P165.cpp */ #include const int KleinsteBreedte= 1, KleinsteHoogte= 1, GrootstBreedte= 39, GrootsteHoogte= 24; class Rechthoek

// basisklasse

{ protected:

// protected zodat de leden toegankelijk zijn

int hoogte;

// vanuit de afgeleide klasse

int breedte; public: Rechthoek(int h= KleinsteHoogte, int b= KleinsteBreedte); void print(); }; class FlexRechthoek : public Rechthoek

// afgeleide klasse

{ private: char symbool; public: // declaratie van de constructor voor FlexRechthoek FlexRechthoek(int ht, int br, char symb= ‘*’); void breder(); void hoger(); void print(); };

// lidfuncties van Rechthoek Rechthoek::Rechthoek(int h, int b) { hoogte= h; breedte= b; }

// overridden

98

void Rechthoek::print() { for (int r= 0; r < hoogte; r++) { for (int k= 0; k < breedte; k++) cout<<”* “; cout<<endl; } } // lidfuncties van FlexRechthoek FlexRechhoek::FlexRechthoek(int ht, int br, char symb):Rechthoek(ht, br) { symbool= symb; } void FlexRechthoek :: breder() { if (breedte < GrootsteBreedte) breedte++; } void FlexRechthoek :: hoger() { if (hoogte < GrootsteHoogte) hoogte++; } void FlexRechthoek::print() { for (int r= 0; r < hoogte; r++) { for (int k= 0; k < breedte; k++) cout<<symbool<<’ ‘; cout<<endl; } } void main() { FlexRechthoek R(3, 5, ‘#’; R.print(); cout<<endl; R.breder(); R.breder(); R.hoger(); R.print(); cin.get(); }


99

4.4.3 Functie overriding versus functie overloading Niettegenstaande zowel bij functie overriding als bij functie overloading het gaat over verschillende functies met dezelfde naam, zijn overriding en overloading wel verschillende zaken. •

Bij overloading moeten de functies (met dezelfde naam) een verschillend aantal argumenten hebben, of moeten de argumenten van de functies van verschillend type zijn.

•

Bij overriding hebben de functies in de basisklasse en in de afgeleide klasse niet alleen dezelfde naam, maar ook nog precies dezelfde argumenten.

Merk op: In literatuur over C++ wordt overriding toch soms aangeduid met ‘overloaden van een functie’. Men heeft het dan over ‘specialisatie’ van een klasse. Specialisatie van een klasse betekent het modifieren van een bestaande klasse naar nieuwe vereisten van de programmeur. Dit kan gebeuren door functies uit een basisklasse te ‘overloaden’ met nieuwe functies. Overloading van een lidfunctie wordt vooral gebruikt wanneer we een ‘uitzondering op de regel’ tegenkomen, dit wil zeggen wanneer een afgeleide klasse zich volledig gedraagt volgens de basisklasse, uitgezonderd voor één functie die anders dient te worden geïmplementeerd. Voorbeeld: class Vogel { private: int poten; int vleugels; int standVleugels, standPoten; public: Vogel() { poten= 2; vleugels= 2; standVleugels= RUST; standPoten= RUST; } void voortbewegen() { standVleugels= OP_EN_NEER; standPoten= RUST; } };

100

class Struisvogel : public Vogel { void voortbewegen() { standVleugels= RUST; standPoten= HEEN_EN_WEER; } }; In het beschouwde voorbeeld ‘is een’ struisvogel een vogel, maar bij het voortbewegen gebruikt de struisvogel niet zijn poten. Dit komt tot uitdrukking in de afgeleide klasse door het herdefiniëren van de lidfunctie voortbewegen().

4.4.4 Overridden functie aanroepen vanuit de afgeleide klasse De oorspronkelijke print-functie van de basisklasse blijft bruikbaar door ze aan te roepen vanuit een lidfunctie van de afgeleide klasse, voorafgegaan door de naam van de basisklasse en de scope-operator. Voorbeeld:

Rechthoek :: print();

4.5 Toegangsregels 4.5.1 Algemeen De woorden private, protected en public heten ‘access specifiers’. Ze specificeren de toegang (access) tot de leden die in het gedeelte achter de access specifier in de klasse staan. Voorbeeld: class X { private: int a:

// enkel toegankelijk voor functies van de eigen // klasse X

protected: int b;

// toegankelijk voor functies van de eigen klasse X // en voor ‘friends’

public: int c;

// toegankelijk voor alle functies

}; Daarbij wordt de toegang tot een lid niet enkel bepaald door de access specifier alleen, maar ook door de plaats van waaruit dat lid benaderd wordt. Tenslotte kan een klasse ofwel privaat, ofwel publiek afgeleid worden. Dit verschil in afleiding manifesteert zich ook in de toegang tot de leden van de basisklasse.


101

4.5.2 Toegangsregels van een privaat afgeleide klasse Het privaat afleiden van een klasse gebeurt als volgt: class Dprivaat : private B { ... }; met B de basisklasse en Dprivaat de privaat afgeleide klasse van B. In een privaat afgeleide klasse gelden de volgende toegangsregels voor de overgeërfde leden van de basisklasse: 1) Ontoegankelijke leden van de basisklasse blijven ontoegankelijk in de afgeleide klasse. ‘Ontoegankelijke leden’ slaat op het feit dat de basisklasse reeds afgeleid kan zijn van een andere klasse, met als gevolg dat bepaalde leden van de basisklasse niet meer toegankelijk zijn. Voor een root-klasse, dit is een klasse die geen ‘voorouders’ heeft, gelden slechts drie toegangsniveau’s: privaat, beschermd en publiek. Voor een afgeleide klasse worden de toegangsniveau’s uitgebreid met ‘ontoegankelijk’. 2) Private leden van de basisklasse zijn ontoegankelijk voor de afgeleide klasse. 3) Beschermde en publieke leden van de basisklasse worden privaat in de afgeleide klasse. Een privaat afgeleide klasse is een zeer veilige afleiding. Immers, alle leden van de basisklasse worden ofwel ontoegankelijk, ofwel privaat in de afgeleide klasse. Bemerk dat een afgeleide klasse default privaat afgeleid wordt.

4.5.3 Toegangsregels voor een publiek afgeleide klasse Het publiek afleiden van een klasse gebeurt als volgt: class Dpubliek : public B { ... } met B de basisklasse en Dpubliek de publiek afgeleide klasse van B. Voor een publiek afgeleide klasse gelden volgende regels: 1) Ontoegankelijke leden van de basisklasse blijven ontoegankelijk in de afgeleide klasse. 2) Private leden van de basisklasse zijn ontoegankelijk voor de afgeleide klasse. 3) Beschermde leden van de basisklasse blijven beschermd in de afgeleide klasse. 4) Publieke leden van de basisklasse blijven publiek in de afgeleide klasse. Een afgeleide klasse wordt meestal publiek afgeleid. Een publiek afgeleide klasse behoudt immers alle toegangsregels die gelden voor de basisklasse, uitgezonderd voor private basisleden.

102

4.5.4 Voorbeeld class X { // Elke lidfunctie van een klasse heeft toegang tot alle andere leden // van dezelfde klasse, ongeacht de access specifier. private: int a; void func_a(); protected: int b; void func_b(); public: int c; void func_c(); }; class Y : public X { // Lidfuncties van Y hebben toegang tot de protected en public leden van X, // dus toegang tot b, func_b, c en func_c. ... }; class Z : private X { // Lidfuncties van Z hebben geen toegang tot de protected en // public leden van X. ... }; Van buitenaf zijn enkel de publieke leden c en func_c toegankelijk. Voorbeeld: void main() { X objx; cout<
// kan niet, want a is privaat

objx.func_a();

// kan niet, want func_a() is privaat

cout<
// kan niet, want b is beschermd (protected)

objx.func_b();

// kan niet, want func_b() is beschermd

cout<
// kan wel

objx.func_c();

// kan wel

} Een klasse die is afgeleid met de access specifier private (class Z : private X) erft wel alle leden van de basisklasse, doch heeft enkel toegang tot de publieke leden van de basisklasse. Een privaat afgeleide klasse heeft dus geen speciale privileges met betrekking tot de toegang.


103

4.5.5 Overzichtstabel access specifier

(1)

(2)

(3)

(4)

public

ja

ja

ja

ja

protected

ja

ja

nee

nee

private

ja

nee

nee

nee

van een lid van de klasse

(1): toegang vanuit eigen lidfuncties? (2): toegang vanuit public afgeleide klassen? (3): toegang vanuit private afgeleide klassen? (4): toegang vanuit object?

4.5.6 Data hiding Een belangrijk principe in OOP is data hiding. Dit is het afschermen van de gegevens van een klasse. Het afschermen gebeurt met de access specifier ‘private’. Enkele overwegingen: 1) Met afgeleide klassen kan het zinvol zijn om bepaalde gegevens uit de basisklasse ‘protected’ te maken. Het zijn die gegevens die gebruikt worden in één of meer lidfuncties van de afgeleide klasse. 2) Data-elementen (data-leden) worden zelden ‘public’ gedeclareerd, omdat daarmee het principe van data hiding te veel wordt aangetast. 3) Veel lidfuncties zijn public gedeclareerd, doch in bepaalde gevallen is dat niet wenselijk. Functies die een helpende rol spelen bij het werk van andere lidfuncties, mogen van buitenaf niet kunnen worden aangeroepen om fouten te vermijden. Dergelijke help-functies worden het best ‘private’ of ‘protected’ gedeclareerd, zodat ze niet van buitenaf kunnen worden aangeroepen. 4) Als een klasse wel lidfuncties heeft, maar geen enkele afgeleide klasse, moet er tenminste één functie ‘public’ zijn, omdat anders geen enkele functie van de klasse kan worden aangewend.

4.5.7 Invloed van overerving op de bescherming van leden van een klasse Bij de overerving van een basisklasse naar een afgeleide klasse, kan de afgeleide klasse aangeven wat er moet gebeuren met de public, protected en private gedeelten van de klasse. Door het opgeven van de keywords private, protected en public vóór de naam van de basisklasse, geeft de afgeschermde klasse aan wat de minimale afscherming van de klasse-leden moet zijn. •

public overerving: alle public leden blijven public, de protected leden blijven protected en de private leden zijn voor de lidfuncties van de afgeleide klasse

104

toegankelijk. Public overerving is de enige vorm van overerving die leidt tot een ‘is een’ relatie. •

protected overerving: alle public leden worden protected, de protected leden blijven protected en de private leden zijn niet voor de leden van de afgeleide klasse toegankelijk.

•

private overerving: alle public leden worden privaat, de protected leden worden privaat en de private leden zijn voor de leden van de afgeleide klasse niet toegankelijk.

Overzicht: overerving

public

protected

private

leden

leden

leden

public

protected

private

protected

protected

private

private

private

private

public overerving protected overerving private overerving

4.5.8 Een ‘is een’ – relatie Overerving is een manier om een ‘is een’- relatie of een ‘gelijkend op’- relatie uit te drukken. Zo kunnen we zeggen: “Een krokodil is een reptiel”. Een krokodil heeft eigenschappen die gemeenschappelijk zijn aan alle reptielen. Een krokodil heeft die eigenschappen geërfd van de reptielen. Andere voorbeelden: een rechthoek is een veelhoek, een mus is een vogel, een auto is een voertuig. Een veel gemaakte fout is dat men een afgeleide klasse wil construeren om een ‘deel van’ - relatie of een ‘heeft een’- relatie uit te drukken. Een krokodil is duidelijk geen ‘deel van’ een reptiel. Als een ‘heeft een’ – relatie tussen twee objecten vereist is, dan moet het ene object als attribuut van het andere object worden gespecificeerd.

4.5.9 Beschermende interface via een afgeleide klasse Door van een basisklasse een afgeleide klasse te maken, die zelf geen extra dataleden toevoegt, kan op een eenvoudige wijze een beschermend omhulsel omheen de basisklasse worden gelegd. Zo’n omhulsel kan de lidfuncties van de basisklasse verbergen. Voorbeeld: De basisklasse Rekening biedt de mogelijkheid een bedrag op een rekening te storten en/of een bedrag op te nemen. Omdat de bankwereld eist dat elke transactie moet worden vastgelegd, is het niet voldoende de basisklasse als volgt te definiëren:


105

class Rekening { private: long rekeningnummer; ... protected: float saldo; ... }; en vervolgens afgeleide klassen te creëren met interfaces voor het storten en opnemen van geld. Immers, op die manier wordt de verantwoordelijkheid voor de transactieregistratie gelegd bij de afgeleide klassen en het kan best dat de maker van de afgeleide klassen, die niet noodzakelijker wijze de maker is van de basisklasse, vergeet deze registratie te implementeren. Een mogelijke oplossing is: class Rekening { private: long rekeningnummer; float saldo; protected: Rekening(long reknr, float start= 0) : saldo(start), rekeningnummer(reknr) {} public: void storten(float bedrag) { saldo += (bedrag > 0 ? bedrag : 0); // log de transactie } void opname(float bedrag) { if (saldo > bedrag) { saldo -= (bedrag > 0 ? bedrag : 0); } // log de transactie } float haalsaldo() const { // log info-verzoek } }; De registratie is nu een onderdeel van de klasse Rekening. Echter, niemand kan de klasse Rekening gebruiken omdat de constructor protected is. Enkel afgeleide klassen kunnen wél de constructor gebruiken.

106

Een voorbeeld van afgeleide klasse van de klasse Rekening is de hypotheeklening (class HypoRekening). Op deze rekening mag enkel kunnen worden gestort, nooit van opgenomen. Het opnemen gebeurt slechts éénmalig via de constructor van de afgeleide klasse HypoRekening. Om het onmogelijk te maken de basisklasse Rekening te gebruiken zonder transactielogging, volstaat het de klasse HypoRekening privaat af te leiden van de basisklasse Rekening. class HypoRekening : private Rekening { private: float stortingskosten(float f) { ... } void storten(float bedrag) { float x= stortingskosten(bedrag); Rekening::storten(bedrag – x); } public: HypoRekening(long rek, float start) : Rekening(rek, - start) {} void aflossing(float bedrag) { storten(bedrag); } Rekening :: getsaldo; };

4.6 Meer dan één afgeleide klasse 4.6.1 Schematische voorstelling Uit een basisklasse kan meer dan één afgeleide klasse worden gemaakt. Zo kan bijvoorbeeld uit de basisklasse Persoon de afgeleide klassen Student en Werknemer worden gemaakt. Dit kan schematisch als volgt worden voorgesteld: Persoon

Student

Werknemer

De pijl betekent: ‘is afgeleid van’. De klasse Student is afgeleid van de klasse Persoon, en ook de klasse Werknemer is afgeleid van de klasse Persoon. T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

107

De schematische voorstelling geeft volgende reële situatie weer: een student is een persoon en ook een werknemer is een persoon.

4.6.2 Waar komt wat? In de basisklasse komen de data-elementen en de lidfuncties die gemeenschappelijk zijn voor studenten als voor werknemers, zoals naam, adres, geboortedatum en een print-functie om die gegevens op het scherm af te drukken. In de basisklasse komen dus de globale, algemene kenmerken. In de afgeleide klasse komen de meer specifieke kenmerken. Een student is bijvoorbeeld ingeschreven in een bepaalde school, en een werknemer is ingeschreven in een welbepaald bedrijf.

4.6.3 Programmavoorbeeld In het volgende programma worden de klasse Student en Werknemer afgeleid uit de basisklasse Persoon. Het algemeen kenmerk is ‘naam’ en de specifieke kenmerken zijn ‘school’ (Student) en ‘bedrijf’ (Werknemer). /* programma P166.cpp */ #include class Persoon { private: char naam[30]; public: Persoon(); void print; }; class Student : private Persoon { private: char school[30]; public: Student(); void print(); }; class Werknemer : private Persoon { private: char bedrijf[30]; public: Werknemer(); void print(); };

108

Persoon :: Persoon() { cout<<”Naam: “; cin>>naam; } void Persoon :: print() { cout<>school; } void Student :: print() { Persoon :: print(); cout<<” is student van “<<school<<endl; } Werknemer :: Werknemer() { cout<<”Bedrijf: “; cin>>bedrijf; cin.get(); } void Werknemer :: print() { Persoon :: print(); cout<<” is werknemer van “<

109

2) De klassen Student en Werknemer zijn privaat afgeleid van de basisklasse Persoon. Dit betekent dat het data-lid ‘naam’ van Persoon niet rechtstreeks toegankelijk is vanuit de afgeleide klassen Student en Werknemer, doch enkel via de publieke lidfuncties Persoon() en print() van de klasse Persoon. In het algemeen is het een goede strategie om zoveel mogelijk leden en afleidingen privaat te maken. Op die manier blijft het principe van data hiding het best gewaarborgd. 3) De drie klassen hebben elk hun eigen print-functie. Dit is een typisch voorbeeld van overriding. In de print-functie van de afgeleide klassen wordt gebruik gemaakt van de print-functie van de basisklasse. Dit gebeurt door de naam van de basisklasse te plaatsen, gevolgd door de scope-operator en de naam van de functie, hier print(), en wel als volgt: Persoon :: print(); . 4) In de constructor van Student en van Werknemer wordt niet naar een naam gevraagd. Toch moet wel degelijk een naam worden ingevoerd voor Student en ook voor Werknemer. Dit komt omdat bij de declaratie van een object van een afgeleide klasse, bijvoorbeeld Student S, eerst automatisch de default-constructor van de basisklasse wordt aangeroepen, in het voorbeeld Persoon(). Eigenlijk ligt dat gebeuren wel voor de hand aangezien de afgeleide klasse voortkomt uit de basisklasse. Dus, pas als de constructor van de basisklasse zijn werk gedaan heeft, wordt de body van de constructor van de afgeleide klasse uitgevoerd.

4.6.4 Constructoren en afgeleide klassen Bij het maken van objecten van een afgeleide klasse geldt in C++ de basisregel dat eerst automatisch de default-constructor van de basisklasse wordt aangeroepen, voordat de passende constructor van de afgeleide klasse wordt uitgevoerd. Echter kan met die basisregel niet alle gevallen correct worden beschreven, zoals in volgende twee situaties: 1) Wat gebeurt er als de basisklasse geen default-constructor heeft? Als de basisklasse geen enkele constructor heeft, maakt de compiler een default-constructor aan, die dan een object van de basisklasse maakt en verder niets. Als de basisklasse wel één of meer constructoren heeft, maar geen defaultconstructor, treedt er een foutmelding op. Die fout kan worden opgeheven door ofwel een constructor zonder argumenten toe te voegen aan de basisklasse, ofwel door alle argumenten van een bestaande constructor in de basisklasse een default-waarde te geven, zodat een default-constructor ontstaat. 2) In een aantal situaties wordt de default-constructor van de basisklasse niet eerst aangeroepen. Dit gebeurt wanneer de constructor van de afgeleide klasse via een initializer expliciet een constructor, niet de default constructor, van de basisklasse aanroept.

110

4.7 Afgeleide klasse van een afgeleide klasse 4.7.1 Schematische voorstelling Het is mogelijk een klasse af te leiden van een klasse, die zelf een afgeleide klasse is. Zo kan bijvoorbeeld de klasse Vierkant worden afgeleid van de klasse Rechthoek, die zelf afgeleid is van de klasse Veelhoek. Dit kan schematisch als volgt worden voorgesteld: Veelhoek

Rechthoek

Vierkant

De richting van de pijl loopt van de afgeleide klasse naar de basisklasse. De klasse Vierkant is een afgeleide klasse van Rechthoek, terwijl Rechthoek zelf een afgeleide klasse is van Veelhoek. Immers, een vierkant is een speciale rechthoek, namelijk een rechthoek met gelijke lengte en breedte, en een rechthoek is een speciale veelhoek, namelijk een met vier rechte hoeken. Men gebruikt volgende terminologie: De klasse Rechthoek is een directe basisklasse van Vierkant. Zo ook is de klasse Veelhoek een directe basisklasse van Rechthoek. De klasse Veelhoek daarentegen is een indirecte basisklasse van Vierkant.

4.7.2 Programmavoorbeeld Het volgende programma maakt gebruik van de klasse Veelhoek, van de klasse Rechthoek, die is afgeleid van Veelhoek, en van de klasse Vierkant, die is afgeleid van Rechthoek. /* programma P167.cpp */ #include class Veelhoek { private: int nthoeken; public: Veelhoek(int nthoek) { nthoeken= nthoek; } T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

111

void print() { cout<<”Aantal hoeken is “<
112

3) De uitvoer levert op: “Aantal hoeken is 4”. Vierkant heeft Rechthoek als basisklasse en Rechthoek heeft Veelhoek als basisklasse. Ook nu geldt de vuistregel dat automatisch eerst de defaultconstructor van de basisklasse wordt aangeroepen, te beginnen met de bovenste klasse, hier Veelhoek. Hoewel Veelhoek zelf geen default-constructor heeft, leidt het aanroepen van Veelhoek niet tot een foutmelding. Dit komt doordat Rechthoek via een initializer de constructor met een argument van de basisklasse Veelhoek aanroept, waardoor het aantal hoeken op vier wordt gezet, namelijk: Rechthoek(int lt= 0, int br= 0) : Veelhoek(4) { lengte= lt; breedte= br; } 4) Bij de declaratie

Vierkant V(20);

zoekt de compiler naar een geschikte constructor van de klasse Vierkant en vindt die met Vierkant(int zijde) { lengte= zijde; breedte= zijde; } Omdat Vierkant een afgeleide klasse is, wordt deze constructor nog niet direct uitgevoerd, maar gaat de compiler nog eerst op zoek naar de defaultconstructor van de directe basisklasse, hier Rechthoek. En Rechthoek heeft een constructor met enkel default-argumenten (= defaultconstructor): Rechthoek(int lt= 0, int br= 0) : Veelhoek(4) { lengte= lt; breedte= br; } Ook deze constructor zou nog niet worden uitgevoerd omdat ook Rechthoek een afgeleide klasse is. Normaal gaat de compiler nu op zoek naar een defaultconstructor van de basisklasse Veelhoek, doch nu gebeurt dat niet omdat hier een andere constructor van Veelhoek direct wordt aangeroepen. Dus wordt hier volgende constructor wel direct uitgevoerd: Rechthoek(int lt= 0, int br= 0) : Veelhoek(4) { lengte= lt; breedte= br; } 5) De constructoren worden uitgevoerd in omgekeerde volgorde van aanroepen: -

eerst Veelhoek(4): deze zet het aantal hoeken op vier

-

dan Rechthoek(0, 0): deze zet lengte= 0 en breedte= 0

-

tenslotte Vierkant(20): deze zet lengte= 20 en breedte= 20


113

6) Om te vermijden dat via Rechthoek(0, 0) eerst lengte en breedte op nul worden gezet, kan in de constructor van Vierkant via een initializer de constructor van Rechthoek worden opgeroepen met de jusite waarde voor lengte en breedte. De constructor van Vierkant wordt dan: Vierkant(int zijde) : Rechthoek(zijde, zijde) {} De body van deze constructor is leeg omdat het volledige werk al gedaan is door de aanroep van Rechthoek(zijde, zijde). Wel is een body verplicht, maar die mag leeg zijn. Merk op: In de definitie van een constructor kan enkel een initializer voor een directe basisklasse worden opgenomen. In de constructor Vierkant kan Rechthoek worden aangeroepen omdat Rechthoek de directe basisklasse is van Vierkant. Echter kan in de constructor Vierkant met een initializer de constructor van Veelhoek niet worden aangeroepen, omdat Veelhoek niet een directe basisklasse is van Vierkant.

4.8 Meervoudige overerving (multiple inheritance) 4.8.1 Algemeenheden Meervoudige overerving betekent dat een klasse eigenschappen erft van meer dan één basisklasse, met andere woorden, een klasse wordt afgeleid uit twee of meer basisklassen. Meervoudige overerving wordt ook aangeduid met ‘meervoudige basisklasse’. Een meervoudige basisklasse is een klasse die erft van meerdere basisklassen. Een meervoudige basisklasse bevat zowel karakteristieken van de ene basisklasse als van de andere basisklasse. Men kan zeggen dat een klasse die erft van meerdere basisklassen, een meervoudige ‘is een’- relatie onderhoudt met de basisklassen. We kunnen de meervoudig afgeleide klasse gebruiken daar waar één van zijn basisklassen verwacht wordt. Voorbeeld: Een kat is enerzijds een huisdier en anderzijds een katachtige. Zowel huisdieren als katachtigen zijn zoogdieren. Dit komt overeen met volgende erfelijkheidsrelatie: Zoogdier

Katachtige

Huisdier

Kat

114

Meervoudige overerving wordt enkel gebruikt waar het werkelijk verantwoord is, omdat meervoudige overerving gemakkelijk leidt tot ingewikkelde erfelijkheidsrelaties met het gevaar van het creëren van contradicties in de ‘stamboom’ van klassen.

4.8.2 Programmavoorbeeld In volgend programma is de klasse X meervoudig afgeleid van de klassen A en B. Schematisch kan dit als volgt worden voorgesteld:

A

B

X

/* programma P168.cpp */ #include class A { protected: int a; public: A() { a= 1; } void print() { cout<<”De waarde van a = “<

115

class X : public A, public B { public: void print() { cout<<”Voor objecten X geldt: “<<endl; cout<<” a = “<
4.8.3 Ambiguïteit bij meervoudige overerving Bij meervoudige overerving kan gemakkelijk ambiguïteit ontstaan omdat basisklassen leden met dezelfde naam kunnen hebben. In volgend programma hebben de leden ‘identiteit’ en ‘spreek()’ van de klassen Moeder en Vader dezelfde naam. In de code is aangeduid waar ambiguïteit kan optreden. Ook de oplossing staat vermeld. /* programma P169.cpp */ #include

116

class Moeder { protected: char identiteit[30]; public: Moeder() { strcpy(identiteit, “Ik ben de moeder.”); } void spreek() { cout<
// ambigu

Kind() { strcpy(Moeder :: identiteit, “Ik ben hun kind.”); } }; void main() { Vader Pa; Moeder Ma; Kind K; Pa.spreek(); Ma.spreek(); //K.spreek();

// ambigu

K.Moeder::spreek();

// niet ambigu

// een betere oplossing is Kind zijn eigen functie spreek() te geven } In het programma treedt er twee keer ambiguïteit op: 1) Kind() { strcpy(identiteit, “Ik ben hun kind.”); } Gezien Kind zowel van Moeder als van Vader een identiteit erft, is het voor de compiler onduidelijk welke identiteit bedoeld wordt in de constructor van Kind. Immers, de ene identiteit heet voluit Moeder::identiteit, en de ander heet voluit Vader::identiteit. Deze ambiguïteit wordt opgelost door één van beide identiteiten aan te geven, zoals: Kind() { strcpy(Moeder :: identiteit, “Ik ben hun kind.”); } 2) K.spreek(); Omdat Kind zowel van Vader als van Moeder een functie spreek() erft, treedt er ambiguïteit op. De oplossing is gebruik maken van de scope-operator, zoals: K.Moeder::spreek();


117

Zonder ambiguîteit is de uitvoer van het programma: Ik ben de vader. Ik ben de moeder. Ik ben hun kind.

4.9 Virtuele basisklasse 4.9.1 Probleem Bij afleidingen met veel klassen kan gemakkelijk een situatie ontstaan waarbij een basisklasse meer dan één keer wordt gebruikt. Voorbeeld: A

A

int a;

int a;

B

C

X

In het voorbeeld gebeurt er tweemaal indirecte overerving van dezelfde basisklasse A, namelijk: zowel klasse B als klasse C erven van de basisklasse A. Dit betekent dat B een kopie van A bevat en dat ook C een kopie van A bevat. Klasse X erft zowel van B als van C. Dit betekent dat X het data-lid a twee keer erft, één keer van B en één keer van C. Deze situatie is verwarrend omdat er ambiguïtiet optreedt. Immers, de regel cout<<”a = “<
4.9.2 Programma met tweemaal indirectie overerving van dezelfde klasse In volgend programma wordt tweemaal overgeërfd van dezelfde basisklasse, namelijk: klasse B erft van klasse A en ook klasse C erft van klasse A. Klasse X erft zowel van B als van C, zoals getoond in vorig schema van de erfelijkheidsrelatie. /* programma P170.cpp */ #include

118

class A { protected: int a; public: A() { a= 1; } void print() { cout<<”De waarde van a = “<
//ambigu

cout<<”De waarde van a = “<

119

void main() { X objX; objX.print(); }

4.9.3 Oplossing met behulp van een virtuele basisklasse 4.9.3.1 Programma Volgend programma lost het probleem van ambiguïteit op bij tweemaal indirecte overerving van dezelfde basisklasse. Dit gebeurt door van de klasse A een virtuele basisklasse te maken. Als klasse A een virtuele basisklasse is, dan delen B en C een kopie van A, in plaats dat ze elk hun eigen kopie van A bevatten. Dit betekent dat in de klasse X de leden van A nu slechts één keer voorkomen. /* programma P171.cpp */ #include class A { protected: int a; public: A() { a= 1; } void print() { cout<<”De waarde van a = “<
120

void print() { cout<<”De waarde van c = “<
// niet meer // ambigu

cout<<”De waarde van b = “<
4.9.3.2 Virtuele basisklasse Een virtuele basisklasse wordt gemaakt door het keyword ‘virtual’ in de definitie van de afgeleide klasse te plaatsen. Voorbeeld: class B : virtual public A { ... };

4.9.3.3 Schematische voorstelling Bij de declaratie van een object van de klasse X wordt de inhoud van klasse A gedeeld door B en C. Schematisch wordt dit: De streeplijnen betekenen dat A een virtuele basisklasse is van B en C, dit wil zeggen: B en C delen de inhoud van A, zodat er slechts één exemplaar van A in een object van de klasse X terecht komt.


121

A int a;

B

C

X

Echter, bij declaratie van B objB; C objC; hebben objB en objC elk hun eigen A-gedeelte. Slechts bij de declaratie van een object van de klasse X wordt bij de constructie van dat object rekening gehouden met het virtuele karakter van klasse A, en wordt het object van de basisklasse opgebouwd met maar één A-gedeelte.

4.10 Templates 4.10.1 Definitie Een template is een mechanisme voor het genereren van functies en klassen, gebaseerd op parameters die het type bepalen. Daarom worden templates ook geparameteriseerde types genoemd. Er wordt onderscheid gemaakt tussen templates voor functies en templates voor klassen. Door het gebruik van een klassetemplate volstaat één klassedefinitie voor verschillende types. Zonder klassetemplate moet per type een andere klasse worden gedefinieerd. Een klasse gegenereerd uit een klassetemplate (volgens het type) noemt men een templateklasse. Door het gebruik van een functietemplate volstaat één functiedefinitie die verschillende types aanvaardt. Zonder functietemplate moet per type een andere functie worden gedefinieerd. Een functie gegenereerd uit een functietemplate (volgens het type) noemt men een templatefunctie. Templates betreft de mogelijkheid om de compiler code in C++ te laten genereren aan de hand van een algemene omschrijving van een klasse of een functie. Met die generieke beschrijving kan de compiler de klasse of de functie uitschrijven (genereren) voor specifieke typen.

122

Zo is het bijvoorbeeld mogelijk een algemene klasse Stapel te definiëren, waarna de compiler de klasse kan uitschrijven tot klasse als Stapel voor int, Stapel voor float en Stapel voor string.

4.10.2 Voorbeeld Het minimum van de getallen a en b wordt bepaald door volgende functie: min = (a < b) ? a : b; Toch moet telkens een aparte functie worden geschreven voor elk type getal. Dus:

// min voor int int min(int a, int b) {return (a < b) ? a : b;} // min voor float float min(float a, float b) {return (a < b) ? a : b;} // min voor char char min(char a, char b) {return (a < b) ? a : b;}

Beter is slechts één model te moeten opstellen, waarin een gegeneraliseerd type voorkomt. Zo’n model heet functie-template. Door gebruik te maken van templates kan de duplicatie van deze functies gereduceerd worden tot één functie: template T min(T a, T b) {return (a < b) ? a : b;} De parameter T stelt geen waarde voor, maar een type. De aanroepen van deze functie (met T) bepalen welk type T zal zijn. Hier wordt een template gedefinieerd die de functie min voorstelt, die de parameters a en b aanvaardt. De parameters a en b moeten behoren tot dezelfde klasse, doch de klasse is willekeurig. De functie min() geeft een waarde terug van hetzelfde type als de parameters. Met andere woorden, deze template stelt een functie voor die twee parameters van hetzelfde type aanvaardt en eveneens een variabele van hetzelfde type teruggeeft. Templates bieden dus de mogelijkheid om een functie te definiëren die éénzelfde bewerking uitvoert op verschillende types van objecten, in plaats van telkens dezelfde functie te moeten definiëren voor de verschillende objecten die gebruikt worden in het programma.

4.10.3 Generieke typen Templates hebben vooral te maken met bewerkingen die generisch zijn, zoals het verwisselen van twee objecten, het bepalen van het minimum van een object, het bepalen van het maximum van een object, het bepalen van het gemiddelde van een object, …. In plaats dat de programmeur voor elk type een aparte functie of klasse moet opstellen, kan voor generieke typen dat werk aan de compiler worden overgelaten. Wanneer de omschrijving van de functie of klasse enkel verschilt op het type, is die functie of klasse een generieke functie of klasse.


123

4.10.4 Functietemplate versus preprocessor-macro 4.10.4.1 Voorbeeld met preprocessor-macro /* programma P172.cpp */ #include #define max(x, y) ((x> y) ? x : y) void main() { int a= 10, b= 20; cout<<” max(a, b) = “<<max(a, b) << endl; } De preprocessor zal bovenstaand programma omvormen tot het volgende: #include #define max(x, y) ((x> y) ? x : y) void main() { int a= 10, b= 20; cout<<” max(a, b) = “<<((a > b) ? : b)<< endl; } Typisch is dat max(a, b) wordt vervangen door de macro ((a > b) ? a : b) die beschreven staat in #define. Nu kan dit ‘vervangen door’ voor problemen zorgen. Stel vorig programma met volgende regel: cout<<max(getche(), getche()) <<endl; . De bedoeling is dat de gebruiker de waarde van a en van b kan ingeven. De preprocessor zal echter die regel vervangen door: cout<<((getche() > getche()) ? getche() : getche())<<endl; De gebruiker zal dus drie keer een invoer moeten doen en als de derde invoer niet de grootste waarde is, werkt de functie max niet meer. Zo iets kan niet voorkomen bij templates omdat de werking van templates niet berust op vervanging, maar op instantie (E: instance). Bij templates wordt de functie max gecreëerd en de getche() blijft een actuele parameter. Met macro’s is het ook mogelijk om vlot peren en appels door mekaar te gebruiken. Macro’s zijn niet typesafe. Templates daarentegen zijn wel typesafe. Om de functie max() typesafe te implementeren zonder functietemplate te gebruiken, moet voor elk type een aparte functie max() worden geschreven.

4.10.4.2 Met een functietemplate De problemen en het vele werk bij gebruik van preprocessormacro’s worden profijtig opgelost met een funtietemplate.

124

/* programma P173.cpp */ #include template T max(T a, T b) { return(a > b) ? a : b; } void main() { int a= 10, b= 20; char c= ‘c’, d= ‘d’; double pi= 3.14159, e= 2.71828, g; cout<<max(a, b)<<endl; cout<<max(c, d)<<endl; g= max(e, pi); cout<
4.10.5 Werking van de functietemplate De werking wordt verklaard aan de hand van vorig programma. 1) template Het sleutelwoord template geeft aan dat we te maken hebben met een template en met het formele parametertype T, met ander woorden hoe het type binnen de template zal noemen. Wanneer een functietemplate wordt geïnstantieerd, wordt het formele type T vervangen door het actuele type, bijvoorbeeld int. Indien deze template met een int wordt gebruikt, zal overal in het programma T vervangen worden door int. 2) De definitie van de functietemplate is als volgt: T max(T a, T b) { return(a > b) ? a : b; } De functie max() aanvaardt twee parameters, a en b, van het type T. De returnwaarde is ook van het type T. 3) In de functie main() wordt door aanroep van de functietemplate via cout<<max(a, b)<<endl; een functietemplate geïnstantieerd. 4) Standaard typeconversies worden niet aanvaard door templatefuncties. De compiler zoekt eerst een ‘exact match’ voor de opgegeven parameters in de lijst van reeds geïnstantieerde templatefuncties. Indien dit mislukt, probeert de compiler een nieuwe templatefunctie te instantiëren met een ‘exact match’ voor de opgegeven parameters. Indien dit mislukt, komen de overloaded functies aan de beurt. Indien dit ook mislukt, wordt er een compiler-error gegenereerd.


125

Besluit: Bij het aanroepen van een template met specifieke parameters, wordt een instantie van de betreffende functie gecreërd door de compiler. Met andere woorden, wanneer een template aangeroepen wordt met als eerste parameter ‘char’ en als tweede parameter ‘int’, dan zal een bijhorende functie gecreëerd worden met deze specifieke parameters. Wanneer in een programma driemaal gebruik wordt gemaakt van een template met telkens verschillende parametertypes, dan zullen drie instanties van deze functie worden aangemaakt met de corresponderende parametertypes.

4.10.6 Klassetemplates 4.10.6.1

Gebruik Klassetemplates laten de programmeur toe om een familie van klassen te creëren die op een verschillend type inwerken. Een klassetemplate wordt dus gebruikt wanneer men een klasse wenst te creëren die kan werken met eender welk type van variabele.

4.10.6.2 Programmavoorbeeld Het volgende voorbeeld implementeert een template-array die toelaat arrays te definiëren van willekeurige objecten. Het voorbeeld illustreert ook hoe een afgeleide klasse moet worden geconstrueerd van een template gebaseerde templateklasse. De template ArrayClass definieert een array van een willekeurig type, zowel gewone types zoals integers, floats, als klassen, met een grootte bepaald door het tweede type. Dit tweede type is een int, zodat enkel constanten behorend tot het int-type kunnen worden meegegeven als tweede type. Alleen zo kan een array gedefinieerd worden in de klassedefinitie. /* programma P174.cpp */ #include #include template class ArrayClass { public: ArrayClass(T obj); void SetAt(int pos, T obj); T GetAt(int pos); private: T Tarray[size]; };

126

template ArrayClass :: ArrayClass(T obj) { assert(size > 0>; for (int i= 0; i < size; i++) { Tarray[i]= obj; } } template void ArrayClass :: SetAt(int pos, T obj) { assert(size > 0>; if ((pos >= 0) && (pos < size)) { Tarray[pos]= obj; } } // afgeleide klasse ArrayClassEx template class ArrayClassEx : public ArrayClass { public: ArrayClassEx(T obj) : ArrayClass (obj) {}; int GetSize() { return size }; }; template T ArrayClass : : GetAt(int pos) { if ((pos >= 0) && (pos < size) return (Tarray[pos]); else return NULL; } class Aclass; void main() { ArrayClass <double, 10> FloatArray(0, 0); ArrayClass IntArray(0); ArrayClass ArrayVanKlassen(Aclass); for (int i= 0; i < 5; i++) IntArray.SetAt(i, i*2); for (int i= 0; i < 5; i++) cout<

127

Bespreking: 1) De syntax voor een klassetemplate is: template class Tempclass { // klassedeclaratie } ofwel als volgt: template class Tempclass { // klassedeclaratie } 2) De types gedefinieerd in de klassetemplate worden gebruikt in de declaratie van de klasse. De definitie van de lidfuncties gebeurt met behulp van volgende syntax: template returntype Tempclass : : Memberfunc(arg1, arg2, …) Binnen een lidfunctie kan vrij gebruik worden gemaakt van een templateparameter (T1, T2, …) 3) Voor het aanmaken van een object behorend tot een klasse, die beantwoordt aan een gedefinieerde template, moeten de types, die zullen worden gebruikt in dit object, worden doorgegeven. Dit gebeurt met volgende syntax: TempClass object; . Hier is een object ‘object’ gedefinieerd, die behoort tot een klasse, opgebouwd volgens TempClass met als types float en int.

4.11 Oefeningen 1) Schrijf een programma dat gebruik maakt van de klasse Rechthoek als basisklasse voor de klasse Venster. De klasse Venster erft alles van Rechthoek en zet een kader bestaande uit sterretjes op het scherm. Bijvoorbeeld: Venster V(3, 5): V.print(); levert op: ***** *

*

***** 2) Schrijf een programma dat gebruik maakt van de klasse Uitgave, waarin de titel en de prijs van een uitgave kunnen worden opgeborgen. De klasse Uitgave dient als basisklasse voor volgende afgeleide klassen: •

Tijdschrift, waarin de maand van uitgave wordt opgeslagen

•

Boek, die het aantal bladzijden van het boek en de naam van de auteur bevat

•

CD, die het aantal minuten speeltijd bevat. De gebruiker moet via het toetsenbord alle gegevens voor de verschillende uitgaven (tijdschriften, boeken en CD’s) kunnen invoeren. Naast de lidfuncties voor de invoer, moeten er ook lidfuncties zijn die de ingevoerde gegevens op het scherm zetten. Daarbij vraagt het programma om de gegevens voor een tijdschrift, een boek en een CD.

128

5. Polymorfisme en virtuele lidfuncties 5.1 Virtuele lidfunctie 5.1.1 Het keyword ‘virtual’ Als van een object pas tijdens runtime bepaald moet kunnen worden van welk type dat object is, dan moeten de lidfuncties die daarvan afhankelijk zijn als ‘virtual’ worden gespecificeerd. Het keyword ‘virtual’ moet slechts in de basisklasse worden opgegeven. In afgeleide klassen van die basisklasse mag virtual geplaatst worden, maar het moet niet.

5.1.2 Probleem C++ is streng bij het toewijzen aan pointervariabelen. Zo kan het adres van een ‘unsigned int’ niet worden toegekend aan een pointer naar ‘int’. Echter is C++ minder streng voor pointers naar objecten van klassen en afgeleide klassen. Dit betekent dat het adres van een object van een afgeleide klasse mag toegekend worden aan een pointer naar een object van de basisklasse, wat voor problemen kan zorgen, zoals in volgend voorbeeld.

5.1.3 Voorbeeld van probleemgeval In het volgend programma is de klasse Persoon de basisklasse van de afgeleide klassen Student en Werknemer. Elke klasse heeft een lidfunctie print(), die in elk van de drie klassen iets anders doet. De print-functie van de klasse Persoon wordt in de twee afgeleide klassen dus overridden. In main() worden drie pointers naar objecten van de klasse Persoon gedeclareerd. In die pointers komen adressen van drie objecten, die bij drie verschillende klassen horen. /* programma P175.cpp */ #include class Persoon { protected: char naam[30]; public: Persoon();


void print; };


129

class Student : public Persoon { private: char school[30]; public: Student();


void print(); }; class Werknemer : public Persoon { private: char bedrijf[30]; public: Werknemer(); // default constructor void print(); }; Persoon :: Persoon() { cout<<”Geef naam: “; cin>>naam; cin.get(); } void Persoon :: print() { cout<<”De naam van deze persoon is “<>school; cin.get(); } void Student :: print() { Persoon :: print(); cout<>bedrijf; cin.get(); } void Werknemer :: print() { Persoon :: print(); cout<
130

void main() { Persoon *p, *q, *r;

// declaratie van pointers naar objecten van // de klasse Persoon

p= new Persoon;

// p bevat het adres van een object van // de klasse Persoon

q= new Student;

// q bevat het adres van een object van // de klasse Student

r= new Werknemer;

// r bevat het adres van een object van // de klasse Werknemer

cout<<endl; p -> print(); q -> print(); r -> print(); } Bespreking van het programma: 1) Bij het aanmaken van een object van een afgeleide klasse wordt automatisch de default-constructor van de basisklasse aangeroepen. Bij het aanmaken van een object Student via q= new Student, wordt eerst de default-constructor van Persoon aangeroepen, namelijk: Persoon :: Persoon() { cout<<”Geef naam: “; cin>>naam; cin.get(); } Concreet betekent dit bijvoorbeeld volgende invoer: voor p= new Persoon: Geef naam: Els voor q= new Student Geef naam: Jo

//default-constructor van Persoon

Geef school: SX3

//default-constructor van Student

voor r= new Werknemer Geef naam: Dirk

//default-constructor van Persoon

Geef bedrijf: DN

//default-constructor van Werknemer

2) Voor de opdrachten p -> print(); q -> print(); r -> print(); wordt driemaal de print-functie van Persoon uitgevoerd: De naam van deze persoon is Els De naam van deze persoon is Jo De naam van deze persoon is Dirk De reden is dat de drie pointers, p, q en r, pointers naar Persoon zijn. De compiler gebruikt dan ook de lidfunctie print() van Persoon.


131

5.1.4 Virtuele lidfunctie Om in vorig voorbeeld toch bij elk object zijn eigen print-functie te kunnen gebruiken, moet in de basisklasse van de print-functie een virtuele functie worden gemaakt. Dit gebeurt als volgt: class Persoon { protected: char naam[30]; public: Persoon();


virtual void print;

// virtuele functie

}; Met dezelfde invoer als in vorig programma, wordt nu het resultaat van de opdrachten

p -> print(); q -> print(); r -> print();

als volgt: De naam van deze persoon is Els Jo is student van SX3 Dirk is werknemer van DN Met aanwending van de virtuele functie zoekt de compiler tijdens de uitvoering van het programma, dus in runtime, uit naar wat voor object de pointer wijst: -

de pointer p wijst naar een object Persoon en daarom wordt de printfunctie van Persoon aangeroepen

-

de pointer q wijst naar een object Stuedent en daarom wordt de printfunctie van Student aangeroepen

-

de pointer r wijst naar een object Werknemer en daarom wordt de print-functie van Werknemer aangeroepen

5.2 Dynamische binding (late binding) 5.2.1 Dynamische binding In C++ is het mogelijk de keuze van het type object over te laten aan het programma terwijl het uitgevoerd wordt. In feite bepaalt het proces dus dynamisch met welk type variabele het te maken heeft. Deze methode wordt ‘dynamic binding’ of ‘late binding’ genoemd. Door lidfuncties ‘virtual’ te verklaren, wordt bij een pointer naar een object niet het type van de pointer gebruikt zoals in C, maar juist het type van datgene waar de pointer naar verwijst. Dit gedrag heet ‘dynamic binding’. Zonder dynamische binding is een taal niet object georiënteerd te noemen. Bij de procedurele talen is de aanroep naar een functie bepalend voor wat er gaat gebeuren. In object georiënteerde talen is dit niet zo. De aanroep is slechts een verzoek iets te doen.

132

5.2.2 Late binding versus vroege binding ‘Late binding’ is het fenomeen dat verschillende functies worden opgeroepen tijdens de uitvoering van het programma naargelang het type object. De term ‘laat’ slaat op het feit dat de selectie van de specifieke functie slechts gebeurt nadat het programma opgestart is, terwijl de term ‘binding’ slaat op het relateren van een functienaam met de specifieke versie van de functie. Door het mechanisme van de late binding wordt de lidfunctie van de afgeleide klasse aangeroepen in plaats van de lidfunctie van de basisklasse. ‘Vroege binding’ vindt plaats als de compiler tijdens de vertaling van de broncode vaststelt welke print-functie er gebruikt zal worden. Bij vroege binding wordt de functienaam gekoppeld aan de uitvoerbare code tijdens het compileren. Vroege binding wordt ook aangeduid met statische binding.

5.3 Polymorfisme 5.3.1 Woordverklaring Het griekse woord ‘poly’ betekent veel, en ‘morphos’ betekent vorm. Polymorfisme betekent dus dat een functie in vele vormen kan voorkomen. Een dergelijke functie wordt ook een ‘polymorfe functie’ genoemd.

5.3.2 Gebruik van het concept polymorfisme Polymorfisme slaat op het fenomeen dat een bepaalde functie kan verschillen in uitvoering naargelang het object waarop deze functie inwerkt. In het dagelijkse leven gebruiken we veelvuldig het concept polymorfisme. Wanneer we bijvoorbeeld praten over het besturen van een auto, dan bedoelen we iets heel anders dan wanneer we praten over het besturen van een boot. Nochtans gebruiken we hetzelfde woord ‘besturen’ en bedoelen we éénzelfde soort actie, namelijk het voortstuwen van een voertuig.

5.3.3 Polymorfisme in C++ Polymorfisme wordt in C++ gerealiseerd via virtuele functies. Bij dynamische binding is de aanroep naar een functie slechts een verzoek iets te doen. Wat er moet gedaan worden, beslist het object zelf, op basis van zijn huidig type. Dit kenmerk wordt polymorfisme genoemd. In C++ zijn er twee soorten polymorfisme: 1) Object polymorfisme Object polymorfisme treedt op als een object van een afgeleide klasse wordt toegekend aan een object van de basisklasse. Het object van de afgeleide klasse gaat over in de basisklasse en verliest zijn specifieke kenmerken. 2) Pointer polymorfisme Pointer polymorfisme gebeurt bij virtuele lidfuncties in combinatie met pointers en references, dus nooit bij objecten. Wanneer een object wordt gemanipuleerd via zijn adres en als dat adres is opgeslagen in een pointer naar de basisklasse, zullen toch virtuele lidfuncties van afgeleide klassen worden opgeroepen, met andere woorden, het object behoudt zijn eigenschappen. T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

133

5.3.4 Voorbeeld Stel de implementatie van de basisklasse Voertuig met als afgeleide klassen Auto en Boot. Alle drie de klassen hebben de lidfunctie besturen(). In de basisklasse wordt de lidfunctie besturen() met ‘virtual’ gespecificeerd. De lidfunctie besturen() zal opnieuw worden gedefinieerd in de afgeleide klassen Auto en Boot. Schematisch: Voertuig virtual besturen();

Auto

Boot

virtual besturen();

virtual besturen();

1) In volgende oproepen van de functie besturen() zal de compiler de correcte code genereren voor besturen() behorend tot het object. Auto MijnAuto; Boot MijnZeilbootje; MijnAuto.besturen() // roept besturen() op behorend bij Auto MijnZeilbootje() // roept besturen() op behorend bij Boot De compiler weet welke functie moet gegenereerd worden omdat het type object duidelijk gespecificeerd is. 2) In volgende code liggen de zaken anders. Voertuig *MijnVoertuig; switch (keuze) { case 0: MijnVoertuig= &MijnAuto; break; case 1: MijnVoertuig= &MijnZeilbootje; break; } Hier kan de compiler niet weten welke functie besturen() moet worden gegenereerd bij de opdracht: MijnVoertuig -> besturen(); . Echter, met besturen() als virtual te definiëren, krijgt het programma de mogelijkheid de gepaste functie uit te voeren naargelang MijnVoertuig verwijst naar een object van de klasse Auto of van de klasse Boot. Het oproepen van de juiste functie gebeurt ‘at runtime’. Tijdens de uitvoering van het programma wordt er gekeken naar welk soort object MijnVoertuig verwijst, en wordt de gepaste functie uitgevoerd.

134

Om deze functionaliteit te vervullen wordt elk object van een klasse waar virtuele lidfuncties in gedefinieerd zijn, voorzien van een tabel van verborgen pointers naar deze functies. Wanneer de virtuele functie opnieuw gedefinieerd wordt in een afgeleide klasse, dan zal de voorziene pointer verwijzen naar deze functie. Tijdens de uitvoering zal iedere virtuele functie opgeroepen worden door middel van de gedefinieerde pointer. Concreet zal, wanneer een virtuele functie aangeroepen wordt, die versie van de functie geactiveerd worden die overeenstemt met het object van waaruit de functie wordt aangeroepen, zelfs wanneer het type van het object niet gekend is bij de uitvoering van het programma. Schematische voorstelling: object basisklasse

tabel pointers naar virtuele functies

pointer nr tabel datalid 1

virtual_func1();

datalid 2

virtual_func2(); virtual_func3();

5.3.5

Programmavoorbeeld Het volgende programma is gebaseerd op het programma met de klassen Persoon, Student en Werknemer. Het programma toont aan dat dynamische binding inderdaad tijdens de uitvoering van het programma plaats vindt. De compiler kan van tevoren niet weten of de gebruiker kiest voor de letter s (student) of voor de letter w (werknemer). Het is dus van tevoren, dit is tijdens de compilatie, niet te bepalen of de pointer p zal wijzen naar een object van de klasse Student of naar een object van de klasse Werknemer. Toch wordt de juiste print-functie aangeroepen. /* programma P176.cpp */ #include class Persoon { protected: char naam[30]; public: Persoon();


virtual void print;

// virtuele functie

};


135

class Student : public Persoon { private: char school[30]; public: Student();


void print(); }; class Werknemer : public Persoon { private: char bedrijf[30]; public: Werknemer(); // default constructor void print(); }; Persoon :: Persoon() { cout<<”Geef naam: “; cin>>naam; cin.get(); } void Persoon :: print() { cout<<”De naam van deze persoon is “<>school; cin.get(); } void Student :: print() { Persoon :: print(); cout<>bedrijf; cin.get(); } void Werknemer :: print() { Persoon :: print(); cout<
136

void main() { Persoon *p= NULL; char ch; cout<<”s = student”<<endl; cout<<”w = werknemer”<<endl; cout<<”maak je keuze: “; cin>>ch; if (ch == ‘s’) p= new Student; if (ch == ‘w’) p= new Werknemer; cout<<endl; if (p != NULL) p -> print(); cin.get(); }

5.4 Abstracte basisklasse 5.4.1 Doel en gebruik van een abstracte klasse Een abstracte klasse is een klasse die tot doel heeft om als basisklasse te dienen voor andere klassen. Abstracte klassen worden gewoonlijk gebruikt als men van plan is gebruik te maken van polymorfe functies. Een abstracte klasse stelt een abstract begrip voor. Voorbeeld: Om een hiërarchie van allerlei soorten transportmiddelen, zoals vrachtwagens, vliegtuigen, boten, … voor te stellen, kan een abstracte klasse ‘Transportmiddel’ worden gecreëerd. Deze vormt een soort overkoepelende klasse voor alle soorten transportmiddelen.

5.4.2 Nut van een abstracte klasse Het nut van het gebruik van een abstracte klasse ligt in het feit dat we forceren om bepaalde functies, gemeenschappelijk aan alle afgeleide klassen, te implementeren in deze afgeleide klassen. In het voorbeeld van de abstracte klasse Transportmiddel is de functie voortbewegen() zo’n gemeenschappelijke functie. Ieder transportmiddel heeft een eigen manier om zich voort te bewegen.

5.4.3 Definitie van een abstracte klasse Er bestaat geen sleutelwoord om een abstracte klasse te maken. We duiden impliciet aan dat een klasse abstract is door het creëren van een pure virtuele functie. Dit is een functie die gelijkgesteld wordt aan de NULL-pointer. Op die manier is een lege virtuele functie gedefinieerd. Dit heeft als gevolg dat in elke afgeleide klasse van de abstracte basisklasse, verplicht een polymorfe functie moet worden gecreëerd die de lege functie opvult.


137

Voorbeeld: class Transportmiddel { public: virtual void voortbewegen()= NULL; }; class Auto : public Transportmiddel { public: void voortbewegen() { rijden();} }; class Schip : public Transportmiddel { public: void voortbewegen() { varen();} }; class Vliegtuig : public Transportmiddel { public: void voortbewegen() { vliegen();} };

5.4.4 Programmavoorbeeld Volgend programma tekent een rechthoek en een cirkel met gebruik van de abstracte basisklasse Figuur. /* programma P177.cpp */ #include #include class VGA_scherm { public: VGA_scherm() { int driver= VGA.mode= VGAHI; initgraph(&driver, &mode, “”); } ~VGA_scherm() { closegraph; } };

138

class Punt { public: int x, y; Punt(int xcoord= 0, int ycoord= 0) { x= xcoord; y= ycoord; } }; class Figuur { protected: Punt middelpunt; int breedte, hoogte; public: Figuur(Punt mpt, int br, int hgt); int links() { return (middelpunt.x – breedte/2); } int rechts() { return (middelpunt.x + breedte/2); } int onder() { return (middelpunt.y + hoogte/2); } int boven() { return (middelpunt.y – hoogte/2); } virtual void tekenen()= NULL;

// zuivere virtuele functie

}; Figuur : : Figuur(Punt mpt, int br, int hgt) { middelpunt= mpt; breedte= br; hoogte= hgt; } class Rechthoek : public Figuur { public: Rechthoek(Punt mpt, int br, int hgt) : Figuur(mpt, br, hgt) {} void tekenen(); }; class Cirkel : public Figuur { private: int straal; public: Cirkel(Punt mpt, int strl) : Figuur(mpt, strl*2, strl*2) { straal= strl; } void tekenen(); }; void Rechthoek : : tekenen() { rectangle(links(), boven(), rechts(), onder()); } T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

139

void Cirkel : : tekenen() { circle(middelpunt.x, middelpunt.y, straal); } void main() { VGA_scherm S; Figuur *F[2];

//array van twee pointers naar Figuur

F[0]= new Cirkel(Punt(320, 240), 100); F[1]= new Rechthoek(Punt(320, 380), 30, 70); for (int i= 0; i < 2; i++) F[i] -> tekenen(); } Bespreking van het programma: 1) Een abstracte klasse is een klasse met minstens één zuivere virtuele functie, hier:

virtual void tekenen()= NULL; .

Een virtuele functie moet overridden zijn in de afgeleide klasse. Dit gebeurt hier als volgt: class Rechthoek : public Figuur { public: // . . . void tekenen(); }; class Cirkel : public Figuur { public: // . . . void tekenen(); }; 2) Een abstracte klasse is enkel bruikbaar om daaruit andere klassen af te leiden, en niet om daarvan objecten te declareren. De declaratie

Figuur F;

levert een foutmelding op: “Cannot create a

variable for abstract class Figuur”. Ook is het niet mogelijk abstracte klassen te gebruiken als argumenttype of als returntype van een functie. Immers, bij de overdracht van een argument of bij een return-opdracht, moet een tijdelijk object worden aangemaakt, en van een abstracte klasse kan dat niet. 3) Wel is het mogelijk pointers naar een abstracte klasse te declareren, om die vervolgens naar objecten van een afgeleide klasse te laten wijzen. In main() is een array van pointers naar Figuur gedeclareerd: Figuur *F[2]; . Dankzij het mechanisme van de virtuele functie tekenen(), dus dank zij polymorfisme, worden de objecten F[0] en F[1] getekend door hun eigen lidfunctie tekenen().

140

6. De I/O – bibliotheek van C++ 6.1 De isostream – bibliotheek De I/O-bibliotheek van C++ is de isostream-bibliotheek die standaard bijgeleverd is met de C++ compiler. De isostream-bibliotheek is dus ingebouwd in de C++ taal zelf, maar vormt een aparte klassenbibliotheek. De isostream-bibliotheek maakt input (gegevens komen in de computer) mogelijk van het toetsenbord, van files en van het geheugen, en maakt ook output (gegevens vertrekken uit de computer) mogelijk naar het scherm, naar files en naar het geheugen. De isostream-bibliotheek vervangt de stdio-bibliotheek (standaard i/o) van C, en biedt daarenboven het voordeel dat ze gebruik maakt van alle C++ eigenschappen. Dit betekent onder andere dat input-output operaties via operatoren mogelijk zijn, en dat de functionaliteit van de isostream-bibliotheek via afgeleide klassen kan worden aangepast aan de eigen wensen en noden van de programmeur. Vermijd het mengen van C-streamcommando’s (stdio.h) met C++streamcommando’s (iostream.h), omdat dan de reactie van de compiler onvoorspelbaar is.

6.2 Het begrip stream Een stream is een stroom van gegevens. Een computer is dus te beschouwen als een apparaat waar een stroom van gegevens naar binnen gaat (de input), en waar een stroom van gegevens uitkomt (de output). De input wordt in verband gebracht met de source (bron), waaruit de gegevens gehaald (to get) worden. Gegevens uit de bron halen heet extract, get of fetch. De output stroomt naar een sink (put). Gegevens in de put stoppen heet insert, put of store. Streams worden gedefinieerd in een groot aantal klassen, die de ‘iostream class library’ wordt genoemd. Vanuit een programma gezien is een stream een object van een of andere iostream-klasse. Via de lidfuncties en operatoren van deze objecten kunnen streams worden bewerkt. Een stream kan beschouwd worden als een equivalent van een input/output-device. Een stream representeert dus altijd een ‘medium’, waarnaar input/output-operaties worden uitgevoerd. In C++ is een stream een object, behorend tot een specifieke streamklasse. De karakteristieken van het stream-object worden enerzijds bepaald door de klasse waartoe het object behoort en anderzijds ook door de eigen toevoegingen aan deze klasse.


141

6.3 De verschillende streamklassen 6.3.1 Hiërachie De verschillende streamklassen hebben de volgende hiërarchie: ios

istream

istrstream

ostream

ifstream

iostream

ofstream

fstream

strstream

stdiostream

ostrstream

Er zijn zes belangrijke streamklassen: 1) De istreamklasse verzorgt input van het toetsenbord. Dit is lezen van het toetsenbord. 2) De istrstreamklasse verzorgt input van het geheugen. Dit is lezen van strings. 3) De ifstream verzorgt input van bestanden. Dit is lezen van files. 4) De ostreamklasse verzorgt output naar het beeldscherm. Dit is schrijven naar het beeldscherm. 5) De ostrstreamklasse verzorgt output naar het geheugen. Dit is schrijven naar strings. 6) De ofstreamklasse verzorgt output naar files. Dit is schrijven naar files.

6.3.2 Soorten streams Men onderscheidt drie soorten van streams: 1) de standaard streams met behulp van de istream- en ostreamklasse. 2) in-memory formatting met streams met behulp van de istrstream- en ostrstreamklasse. 3) file I/O met streams met behulp van de ifstream- en ofstreamklasse.

6.3.3 Het vereenvoudigd model van iostream De iostream is modulair en gelaagd opgebouwd. Het vereenvoudigd model ziet er schematisch als volgt uit:

142

ios (formatting)

istream

ostream

(operator>>)

(operator<<)

ifstream (concrete invoer)

•

ofstream (concrete uitvoer)

Bovenaan in de hiërachie is er de klasse ios. Ze bevat formateringsparameters. Het is onmogelijk om objecten van de klasse ios te creëren. Alle lidfuncties van ios zijn bruikbaar vanuit de afgeleide streamklassen. Dit betekent echter niet dat alle opties steeds van toepassing zijn.

•

Van de klasse ios zij er twee klassen afgeleid, een voor invoer (istream) en een voor uitvoer (ostream). In deze klassen zijn ‘operator>>’ en ‘operator<<’ gedefinieerd. Deze klassen verzorgen zelf geen I/O. Ze staan uitsluitend in voor het omvormen van waarden van een bepaald type van en naar een reeks karakters.

•

Onderaan de ladder staan de klassen die door de programmeur worden gebruikt, zoals de klasse ifstream voor invoer uit bestanden, en de klasse ofstream voor uitvoer naar bestanden. Met behulp van het mechanisme ‘virtual’ weet ostream hoe karakters daadwerkelijk naar buiten moeten worden gestuurd en weet istream hoe karakters naar binnen moeten worden gestuurd.

Als een programmeur wenst I/O te doen via andere kanalen, moet hij/zij enkel een nieuwe klasse afleiden van istream en/of van ostream, en de nodige fysieke I/Oaanroepen programmeren. Immers, de formateringskennis wordt geërfd van de klasse ios, en de functies ‘operator >>()’ en ‘operator<<()’ worden geërfd via istream en ostream. De programmeur hoeft daarvoor zelf geen code te schrijven.

6.4 De ostreamklasse De ostreamklasse verzorgt output naar het beeldscherm. Het standaard streamobject cout is een object van de klasse ostream. Bij opnemen in een C++ programma van de headerfile ‘iostream.h’ wordt het object cout standaard voor dat programma gedeclareerd. Met andere woorden, de output van het cout-object wordt automatisch geopend bij de eerste aanroep van het cout-object. Deze output is gebufferd. Dit betekent dat enkel wanneer een buffer met wel bepaalde lengte (normaal 512 bytes) is volgeschreven, dan deze buffer wordt weggeschreven naar het beeldscherm.


143

Men kan de output naar het beeldscherm forceren, zelfs wanneer de buffer nog niet volledig is volgeschreven, door gebruik te maken van de lidfunctie flush(). Voorbeeld: #include void main() { int i= 8; double d= 2.15; char ch= ‘a’; cout << i << endl; cout << d << endl; cout << ch << endl; cout.flush(); } Het object cout is een sink. Het dubbele-kleinere-dan teken << heet de insertionoperator. De pijlen wijzen van de variabele, waarin de waarde zit, naar de sink.

6.5 De istreamklasse De istreamklasse verzorgt de input van het toetsenbord naar de computer. Het standaard streamobject cin is een object van de klasse istream. Bij opname in een C++ programma van de headerfile ‘iostream.h’ wordt het object cin standaard voor dat programma gedeclareerd. Men andere woorden, het object cin is reeds vooraf gedefinieerd en stelt de input van het toetsenbord voor. Voorbeeld: #include void main() { int i; double d; char ch; cin >> i; cin >> d; cin >> ch; cout << i << endl; cout << d << endl; cout << ch << endl; } Het object cin is een source. Het dubbele-groter-dan teken >> heet de extractionoperator. De pijlen wijzen van de bron naar de variabele waarin de waarde terecht komt.

6.6 De ofstreamklasse 6.6.1 De klasse ofstream De klasse ofstream verzorgt de output naar een file. Een object behorend tot deze klasse stelt een specifieke file voor waarnaar geschreven wordt. Die file mag bestaan uit karakters, numerieke waarden, strings of objecten, het maakt niets uit.

144

Een file wordt gemaakt door een streamobject van de klasse ofstream te declareren. Daarvoor moet wel de headerfile ‘fstream.h’ worden opgenomen in het programma.

6.6.2 Een nieuw bestand maken Volgend programma maakt op de schijf C: in de map Luc het bestand demo1 aan en bergt in dat bestand een int, een double en een char op. //programma P178.cpp #include #include void main() { ofstream uitvoer(“C:\\Luc\\demo1”); int i= 8; double d= 2.15; char ch= ‘a’; uitvoer << i << endl; uitvoer << d << endl; uitvoer << ch << endl; } Bespreking van het programma: 1) Het aanmaken van een output stream file, met andere woorden, het creëren van een ofstream-object, gebeurt in het voorbeeld als volgt: ofstream uitvoer(“C:\\Luc\\demo1”); De naam van het ofstream-object is ‘uitvoer’ en de stream wordt gekoppeld aan het bestand met de naam ‘demo1’. Een constructor van de klasse ofstream zorgt voor deze koppeling. Dit proces is het openen van de file demo1 voor schrijven. In deze manier van aanmaken van de outputfile, namelijk tijdens de creatie van het object, wordt direct de bestandsnaam en de mode opgegeven. De mode geeft de wijze aan waarop de file geopend wordt. De algemen notatie is: ofstream eenfile(“filename”, iosmode); Een andere manier voor het aanmaken van een outputfile is eerst het object creëren en dan expliciet de lidfunctie open() aanroepen, zoals in volgend voorbeeld: ofstream eenfile; eenfile.open(“filename”, iosmode); Hierin is eenfile de naam van het ofstream-object en is vrij te kiezen door de programmeur. 2) Betekenis van iosmode De wijze waarop een file geopend wordt, wordt aangegeven met iosmode. De belangrijkste waarden die iosmode kan aannemen zijn:


145

ios::app

de weggeschreven data wordt altijd toegevoegd aan het einde van de file

ios::out

de file wordt geopend voor output (default mode)

ios::trunc

als de file reeds bestaat, wordt de inhoud ervan vernietigd

ios::nocreate

de functie faalt als de file niet bestaat

ios::noreplace

de functie faalt als de file reeds bestat

ios::binary

opent de file in binaire mode (default in text mode)

3) Wanneer een outputstream en een daaraan gekoppelde file geopend is, kan het programma met behulp van de insertion-operator waarden naar de stream sturen. Voorbeeld: uitvoer << i << endl; 4) Het bestand dat in het voorbeeld gemaakt is, is een (ASCII) tekstbestand. Een tekstbestand kan in een editor worden opgevraagd en bekeken. De inhoud van het bestand demo1 is: 8 2.15 a Merk op dat met numerieke waarden een scheidingsteken tussen de waarden nodig is om te voorkomen dat de waarden tegen elkaar plakken, waardoor het lezen niet meer correct kan verlopen. Scheidingstekens zijn een spatie, een tab of een overgang naar een nieuwe regel (endl). Zonder endl is de uitvoer van demo1: 82.15a

6.6.3 Strings schrijven naar een bestand Het schrijven van strings naar een bestand verloopt goed als de strings van elkaar gescheiden worden door een overgang naar een nieuwe regel (endl). Voorbeeld: //programma P179.cpp #include #include void main() { ofstream uitvoer(“C:\\Luc\\demo2”); uitvoer << “string1, “ << endl; uitvoer << “string2, “ << endl; uitvoer << “string3. “ << endl; }

146

6.7 De ifstreamklasse 6.7.1 De klasse ifstream De klasse ifstream verzorgt de input van een file. Een object behorend tot deze klasse stelt een specifieke file voor waaruit gelezen wordt. Het programma moet de headerfile ‘fstream.h’ bevatten.

6.7.2 Een bestand lezen met behulp van een stream Volgend programma leest het bestand demo1 die staat op de schijf C: in de map Luc. //programma P180.cpp #include #include void main() { ifstream invoer(“C:\\Luc\\demo1”); int i; double d; char ch; invoer >> i; invoer >> d; invoer >> ch; cout << i << endl; cout << d << endl; cout << ch << endl; } Bespreking van het programma: 1) Om de gegevens, opgeslagen in het bestand demo1, terug te kunnen lezen, moet een object van de klasse ifstream worden gedeclareerd. Het aanmaken van de inputfilestream gebeurt in het voorbeeld als volgt: ifstream invoer(“C:\\Luc\\demo1”); De naam van het ifstreamobject is ‘invoer’ en de stream wordt gekoppeld aan het bestand ‘demo1’. Een constructor van de klasse ifstream zorgt voor deze koppeling. Dit proces is het openen van de file demo1 voor lezen. In C++ wordt een file om te lezen als volgt geopend: ofwel met ifstream eenfile(“filename”); ofwel met ifstream eenfile; eenfile.open(“filename”); De naam van het ifstream-object is hier eenfile, doch is vrij te kiezen door de programmeur. Het object eenfile van de klasse ifstream wordt gekoppeld aan het bestand filename. De functie open() opent de file ‘filename’ om te lezen uit ‘filename’.


147

2) Als het bestand geopend is, kan met de extraction-operator >> de waarden die in het bestand staan, worden geplaatst in variabelen.

6.7.3 Strings lezen uit een bestand 6.7.3.1 Inlezen van strings met de extraction-operator Volgend programma leest de inhoud van het bestand ‘C:\Luc\demo2’ en zet de gelezen data op het beeldscherm. //programma P181.cpp #include #include void main() { ifstream invoer(“C:\\Luc\\demo2”); char buf[80]; invoer >> buf; cout << buf << endl; invoer >> buf; cout << buf << endl; invoer >> buf; cout << buf << endl; }

6.7.3.2 Probleem met de extraction-operator De extraction-operator leest een string uit een bestand tot aan het eerstvolgend ‘whitespace character’, namelijk een spactie, een tab-karakter of een newlinekarakter. Volgend voorbeeld schrijft de string “Dit is een string met spaties” naar het bestand demo3. Lezen uit demo3 levert slechts de string “Dit” op. //programma P182.cpp #include #include void main() { char buf[80]; ofstream uitvoer(“C:\\Luc\\demo3”); uitvoer << “Dit is een string met spaties” << endl; ifstream invoer(“C:\\Luc\\demo3”); invoer >> buf; cout << buf << endl; }

148

6.7.3.3 Strings lezen uit een bestand met getline() Met de lidfunctie getline() wordt vanuit een invoerstream strings per regel gelezen, dus tot aan een newline-karakter. De lidfunctie getline() bergt een string op in een buffer. Die buffer, evenals de grootte van de buffer, worden als argumenten aan getline() doorgegeven. Het newline-karakter wordt door getline() wel uit de stream gehaald, maar wordt niet opgeslagen in de buffer. Volgend programma leest de volledige string uit het bestand ‘C:\Luc\demo3’: //programma P183.cpp #include #include void main() { char buf[80]; ifstream invoer(“C:\\Luc\\demo3”); invoer.getline( buf, 80); cout << buf << endl; }

6.7.4 Het testen van een stream 6.7.4.1 Mogelijk optredende fouten 1) Om een bestand te kunnen gebruiken, moet dat bestand gekoppeld worden aan een stream. Het bestand wordt dan geopend. Echter kunnen volgende oorzaken een fout opleveren: -

het bestand bestaat niet

-

de opgegeven map bestaat niet

-

er is geen diskette in het opgegeven diskettestation

-

het bestand is tegen schrijven beveiligd

-

de schijf is vol

2) Wanneer een bestand met succes is geopend, kunnen er nog zaken fout gaan, zoals: -

het programma wil meer strings lezen dan het bestand bevat

-

het bestand bevat doubles en het programma leest enkel ints

6.7.4.2 Het testen met de naam van de stream Een eenvoudige manier om een stream te testen op fouten is met behulp van de naam van de stream zelf, zoals in volgend voorbeeld: //programma P184.cpp #include #include


149

void main() { char buf[80]; const char* bestandsnaam = “C:\\Luc\\demo3”; ifstream invoer(bestandsnaam); if (!invoer)

// test1

{ cout << “Bestand “ << bestandsnaam <<” kan niet worden geopend.” << endl <<”Programma-uitvoering beëindigd.”; return;

// naar afsluitaccolade van main()

} invoer.getline( buf, 80); while (invoer)

// test2

{ cout << buf << endl; invoer.getline( buf, 80); } } Bespreking van het programma: 1) Test1 controleert of het koppelen van de stream aan het bestand, en daarmee het openen van het bestand, wel gelukt is. 2) Test2 controleert of het einde van het bestand (end of file) al bereikt is.

6.7.4.3 De lidfunctie fail() Het is belangrijk dat vóór het openen van een file om te lezen, er vooraf getest wordt of die file wel degelijk bestaat. Dit kan gebeuren met de functie fail(). Voorbeeld: ifstream invoer(“filename”, ios::nocreate); if (invoer.fail()) { cout << “File bestaat niet.”; exit(0); } else {// lezen van de file } De lidfunctie fail() levert een waarde op ongelijk aan nul, als de streambewerking mislukt is, anders levert fail() de waarde nul op.

6.7.4.4 Functies die fouten behandelen Elke stream beschikt over een aantal lidfuncties die ons informeren over eventuele fouten tijdens het schrijven naar de stream. 1) bad()

geeft true terug als er een onherstelbare fout is opgetreden.

150

2) fail()

geeft true terug als een streambewerking mislukt is, zoals een

onherstelbare fout, een onjuiste conversie of bestand niet gevonden. Men kan verder werken op de geopende stream door clear(0) uit te voeren. 3) good()

geeft true terug als geen onherstelbare fout is opgetreden en als de

end-of-file vlag niet gezet is. 4) eof()

geeft true terug als een end-of-file vlag gezet is, met andere

woorden, als het einde van het bestand, gekoppeld aan de stream, bereikt is. 5) clear()

zet of herzet de foutstatus van de stream. Aanroep van clear() met

de default parameters wist alle foutbits. 6) rdstate()

geeft de foutstatus terug.

6.8 De strstreamklasse De klasse strstream supporteert het formatteren van strings in het geheugen.

6.8.1 De lidfuncties str() en freeze() De lidfunctie str() geeft de pointer naar de geformatteerde string terug. Op dat moment wordt de buffer bevroren. Dit betekent dat geen nieuwe karakters kunnen verstuurd worden naar een bevroren stream. Bovendien moet de programmeur er zelf voor zorgen dat de buffer gewist wordt wanneer het strstream-object niet meer gebruikt wordt. De lidfunctie freeze(0) geeft de buffer weer vrij. Voorbeeld: ostream eenstring; eenstring << “Dit is een string.” << ends; char* PointerToString = eenstring.str();

//ken pointer toe aan de //string in eenstring

De manipulator ‘ends’ voegt een ‘\0’ toe aan de string. Een manipulator is een middel om de uitvoer of de invoer van een stream te beïnvloeden (manipuleren). Met manipulatoren kan de vormgeving van gehele en gebroken getallen bepaald worden. De string gestockeerd in eenstring is dynamisch gealloceerd.

6.8.2 De manipulator setw en de lidfunctie width() Zowel de manipulator setw als de lidfunctie width() bepalen de breedte van het uit te printen veld. 1) Voorbeeld voor output: Het statement cout << setw(8); of cout.width(8); T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

151

zal de breedte van het volgende uit te printen veld op acht karakters zetten. Dit betekent dat het volgende veld een minimale lengte van acht karakters heeft. Wanneer het uit te printen veld minder dan acht karakters lang is, wordt het veld vooraan opgevuld met blanco’s. Als het veld is uitgeprint, verandert de breedte van het veld opnieuw naar de default waarde. Het gebruik van de manipulator setw vereist de headerfile ‘iomanip.h’ . 2) Voorbeeld voor input: De lidfunctie width() kan ook gebruikt worden voor input. Bij input zal width() de maximaal in te lezen karakters bepalen. Dit kan handig zijn om buffer-overflow te vermijden, zoals in volgend voorbeeld, waar de buffer maximaal 19 karakters zal bevatten + ‘\0’. char buf[20]; cin.width(sizeof(buf)); cin >> buf; cout << buf;

6.8.3 De manipulator setiosflags De manipulator setiosflags maakt het mogelijk om verschillende formaatspecificaties mee te geven.

6.8.3.1 Links uitlijnen Tekst wordt gewoonlijk links uitgelijnd. De opdracht cout << setiosflags(ios::left); zal het volgende veld links uitlijnen. Voorbeeld: //programma P185.cpp #include #include void main() { char* s[3]= {“aa”, “aaa”, “aaaa”}; //De standaard uitlijning is rechts for (int i= 0; i < 3; i++) cout << setw(10) << s[i] << endl; cout << endl; //Links uitlijnen cout << setiosflags(ios::left); for (int i= 0; i < 3; i++) cout << setw(10) << s[i] << endl; }

152

De uitvoer van het programma is: aa aaa aaaa aa aaa aaaa

6.8.3.2 Rechts uitlijnen Getallen in kolommen worden meestal rechts uitgelijnd. De opdracht cout << setiosflags(ios::right); zal het volgende veld rechts uitlijnen. Voorbeeld: //programma P186.cpp #include #include void main() { int reeks[4]= {1, 22, 333, 4444}; cout << setiosflags(ios::right); for (int i= 0; i < 4; i++) cout << reeks[i] << endl; }

6.8.3.3 Een vast aantal cijfers na het decimale punt De ‘ios::fixed’-vlag zorgt ervoor dat floating point getallen worden uitgeprint met een vast aantal cijfers na het decimale punt, en niet in wetenschappelijke notatie. Het vast aantal cijfers na het decimale punt wordt bepaald met de manipulator setprecison(int). De nullen helemaal rechts van het decimale punt kunnen zichtbaar worden gemaakt met de ‘ios::showpoint’-vlag. Voorbeeld: //programma P187.cpp #include #include void main() { double reeks[5]= {1.2, 34.56, 789.123, 1234.5678, 56789.43215}; cout << setprecison(3) << setiosflags(ios::showpoint|ios::fixed); for (int i= 0; i < 5; i++) cout << reeks[i] << endl; }


153

6.8.3.4 Wetenschappelijke notatie De ‘ios::scientific’-vlag zorgt ervoor dat floating point getallen worden uitgeprint in de wetenschappelijke notatie. Het volgende voorbeeld zet de getallen in wetenschappelijke notatie op het scherm, met drie cijfers achter het decimale punt, inclusief nullen. Voorbeeld: //programma P188.cpp #include #include void main() { double reeks[5]= {1.2, 34.56, 789.123, 1234.5678, 56789.43215}; cout << setprecison(3) << setiosflags(ios::showpoint|ios::scientific); for (int i= 0; i < 5; i++) cout << setw(15) << reeks[i] << endl; } De uitvoer van het programma is: 1.200 e+00 3.456 e+01 7.891 e+02 1.235 e+03 5.679 e+04

6.8.3.5 Aanvullen van een veld De lidfunctie fill() zal het veld aanvullen (= ‘padden’) met het gespecificeerde karakter. Zo zal cout.fill(‘*’); het eerstvolgende veld aanvullen met asteriksen ‘*’ in plaats van met het standaard opvulkarakter blanco ‘ ‘. Voorbeeld: //programma P189.cpp #include #include void main() { int reeks[4]= {1, 22, 333, 4444}; for (int i= 0; i < 4; i++) cout.fill(‘*’); cout << setw(5) << reeks[i]; }

154

De uitvoer van het programma is: ****1 ***22 **333 *4444 Het opvullen kan ook met de manipulator setfill: cout << setfill(‘*’) << setw(5) << reeks[i];

6.8.3.6 Talstelsels decimaal, hexadecimaal en octaal De manipulatoren dec, hex en oct bepalen of een geheel getal geschreven of gelezen wordt respectievelijk als een decimaal getal (10-tallig), als een hexadecimaal getal (16-tallig) of als een octaal getal (8-tallig). Voorbeeld: //programma P190.cpp #include void main() { int a= 12, b= 26; cout<<”octaal: “<>hex>>a; cout<<”Typ nog een hexadecimaal getal (getal2) in: “; cin>>hex>>b; cout<<”De decimale waarde van getal1 = “<<dec<
32

hexadecimaal: C

1A

decimaal:

26

12

Typ een hexadecimaal getal (getal1) in: 23 Typ nog een hexadecimaal getal (getal2) in: A2 De decimale waarde van getal1 = 35 De decimale waarde van getal2 = 162

6.8.3.7 De manipulator endl De manipulator endl voegt een ‘carriage return/ linefeed’ combinatie toe aan de outputstream. Bovendien forceert endl het uitprinten van de buffer.


155

6.8.3.8 De manipulator flush De lidfunctie flush() is direct gekoppeld aan het uitschrijven van tekst, en is nodig omdat uitvoer zonder newline, in de buffer blijft zitten totdat de buffer vol is. De lidfunctie flush() schrijft onmiddellijk de uitvoerbuffer weg in de uitvoerstream. cout << “data zonder newline”; cout.flush(); Beter is de koppeling in de code tot uiting te brengen met behulp van de manipulator flush: cout <<”data zonder newline”<
6.9 Input/Output met objecten 6.9.1 I/O van objecten met behulp van lidfuncties De gegevens, opgeslagen in een object, kunnen met behulp van lidfuncties in een stream worden gestopt of uit een stream worden gehaald. Voorbeeld: //programma P191.cpp #include class Punt { private: int coordX, coordY; public: Punt(int x= 0, int y= 0) { coordX= x; coordY= y; } void schrijf(ostream &uitvoer) { uitvoer<<’(‘<>coordX>>coordY; } };

156

void main() { Punt M, N(5, 8); cout<<”Geef de coördinaten voor punt M: “; M.lees(cin); M.schrijf(cout); cout<<endl; N. schrijf(cout); cout<<endl; } De uitvoer van het programma kan zijn: Geef de coördinaten voor punt M: 15 10 (15, 10) (5, 8) De uitdrukking M.lees(cin) roept de lidfunctie ‘lees’ aan van de klasse Punt. De lidfunctie ‘lees’ kent een waarde toe aan de private data-elementen coordX en coordY van het object M. De uitdrukking M.schrijf(cout) plaatst de gegevens van M in de uitvoerstroom cout.

6.9.2 I/O van objecten met behulp van operatoren 6.9.2.1 Opzet Met een object, bijvoorbeeld het object M uit vorig programma, willen we volgende uitdrukkingen kunnen gebruiken: cin >> M; en

cout << M << endl;

Voor wat betreft I/O is er dan geen onderscheid meer tussen variabelen van een standaardtype en variabelen (objecten) van een zelfgedefinieerde klasse. Die opzet wordt verwezenlijkt met behulp van een handige eigenschap van de iostreambibliotheek, namelijk de mogelijkheid om de operatoren << en >> te herdefiniëren in eigen klassen, met andere woorden, het overladen (E: overload) van de operatoren << en >>. Met overloading van de operatoren << en >> is cin >>M;

een andere schrijfwijze voor operator>>(cin, M); met M een argument van het type Punt&, en cin een argument van het type istream&

en is cout << M;

een andere schrijfwijze voor operator<<(cout, M); met M een argument van het type Punt&, en cout een argument van het type ostream&.

6.9.2.2 Voorbeeld Volgend programma leest de coördinaten van het object M van de klasse Punt en print die gegevens op het scherm met behulp van het overladen van de operatoren << en >>.


157

//programma P192.cpp #include class Punt { private: int coordX, coordY; public: Punt(int x= 0, int y= 0)


{ coordX= x; coordY= y; } //declaratie van operator<<(), beschrijving volgt later friend ostream& operator<<(ostream& uitvoer, Punt& p); //declaratie van operator>>(), beschrijving volgt later friend istream& operator>>(istream& invoer, Punt& p); }; // beschrijving van operator<<() ostream& operator<<(ostream& uitvoer, Punt& p) { //zorgt voor de uitvoer naar de stream uitvoer<<’(‘<>() istream& operator>>(istream& invoer, Punt& p) { //zorgt voor de invoer vanuit de stream invoer>>p.coordX>>p.coordY; //zorgt dat de stream als functiewaarde wordt opgeleverd return invoer; { void main() { Punt M; cout<<”Geef de coördinaten voor punt M: “; cin >> M; cout << M << endl; } Bespreking van het programma: 1) Declaratie van ‘operator<<()’ •

Omdat operator<<() toegang moet hebben tot de private leden van Punt, moet dus operator<<() als friend worden gedeclareerd van de klasse Punt.

158

•

De code ‘cout << M’ schrijven als een operator-functie wordt: operator<<(cout, M); Met invulling van de types van de argumenten wordt de uitdrukking: operator<<(ostream& uitvoer, Punt& p); met ‘uitvoer’ een object van de klasse ostream.

•

Het terugkeertype ‘ostream&’ van de functiewaarde van operator<<() is een reference naar ostream. Dit is nodig om de operator << verscheidene keren achter elkaar te kunnen schakelen (een ketting), zoals in cout << M << endl; (zie verder in 2) )

2) Beschrijving van operator<<() •

Het statement return uitvoer; zorgt ervoor dat de stream als functiewaarde wordt afgeleverd. Hier is de functiewaarde een reference naar een ostream. Dit betekent dat de functiewaarde (de stream uitvoer) kan gebruikt worden alsof het een uitvoerstream is. Het gevolg daarvan is dat de operator << verschillende keren achter elkaar kan worden geplaatst zoals in cout << M << endl;

•

Merk op dat volgende kop fout is: ostream& Punt::operator<<(. . .); omdat operator<<() geen lidfunctie is van de klasse Punt. De operator<<() is enkel een bevriende functie van Punt.

3) Met Punt M wordt het object M gecreëerd met M.coordX= 0 en M.coordY= 0. 4) Met cin >> M roept cin de functie operator>>() op en stuurt M mee. Dus:

operator>>(istream& invoer, Punt& p)

cin

M

waarde geven aan M.coordX en aan M.coordY 5) Met het statement cout << M << endl roept cout de functie operator<<() op met M, dus: operator<<(ostream& uitvoer, Punt& p)

cout

M

waarden halen uit M, namelijk M.coordX en aan M.coordY Het statement cout<<M<<endl wordt van links naar rechts uitgevoerd, dus als volgt:

(cout<<M)<<endl; .

Dit betekent dat endl terecht komt in het resultaat van de uitdrukking cout<<M; . En daar cout<<M een andere schrijfwijze is voor operator<<(cout, M), wordt de functie operator<<() aangeroepen met het argument cout en levert dus operator<<() als functiewaarde een reference op naar cout, met als gevolg dat endl in cout terecht komt.


159

6.9.3 Objecten in een bestand 6.9.3.1 Algemeen De gemaakte voorzieningen om de inhoud van de data-leden van objecten via streams te schrijven naar het scherm of te lezen van het toetsenbord, zijn ook bruikbaar om de inhoud van de data-elementen van objecten te schrijven naar een bestand of te lezen uit een bestand. Immers, de klasse ofstream, nodig om naar een bestand te schrijven, is een afgeleide klasse van de klasse ostream. Dit betekent dat de zelfgeschreven functie operator<<(), gedefinieerd voor de klasse ostream, ook bruikbaar is voor ofstream-objecten. Hetzelfde geldt voor de functie operator>>(), die ook bruikbaar is voor ifstream-objecten.

6.9.3.2 Schrijven van objecten naar een bestand Het volgende programma vraagt de coördinaten van de punten M1 en M2, en slaat die data op in het bestand “C:\Luc\punt”. //programma P193.cpp #include #include class Punt { private: int coordX, coordY; public: Punt(int x= 0, int y= 0)


{ coordX= x; coordY= y; } friend ostream& operator<<(ostream& uitvoer, Punt& p); friend istream& operator>>(istream& invoer, Punt& p); }; ostream& operator<<(ostream& uitvoer, Punt& p) { return uitvoer<<’(‘<>(istream& invoer, Punt& p) { return invoer>>p.coordX>>p.coordY; {

160

void main() { Punt M1, M2; cout<<”Geef de coördinaten voor punt M1: “; cin >> M1; cout<<”Geef de coördinaten voor punt M2: “; cin >> M2; // wegschrijven in bestand ofstream uitvoer(“C:\\Luc\\punt”); uitvoer << M1 << M2; uitvoer.close();

//sluit de stream en het daaraan gekoppeld bestand

}

6.9.3.3 Lezen van objecten uit een bestand Het volgende programma leest de coördinaten van de punten M1 en M2 uit het bestand “C:\Luc\punt” en zet die coördinaten op het beeldscherm. //programma P194.cpp #include #include class Punt { private: int coordX, coordY; public: Punt(int x= 0, int y= 0)


{ coordX= x; coordY= y; } friend ostream& operator<<(ostream& uitvoer, Punt& p); friend istream& operator>>(istream& invoer, Punt& p); }; ostream& operator<<(ostream& uitvoer, Punt& p) { return uitvoer<<’(‘<>(istream& invoer, Punt& p) { return invoer>>p.coordX>>p.coordY; {


161

void main() { ifstream invoer(“C:\\Luc\\punt”); Punt M1, M2; invoer << M1 << M2; invoer.close();

//sluit de stream en het daaraan gekoppeld bestand

cout<<”Punt M1 is “<<M1<<” en punt M2 is “<<M2; }

6.9.3.4 Tegelijk objecten lezen uit en schrijven in een bestand Een bestand om in te schrijven moet worden gekoppeld aan een object van de klasse ifstream, en een bestand om uit te lezen moet worden gekoppeld aan een object van de klasse ofstream. Wanneer een bestand is gekoppeld aan een object van de klasse fstream, dan kan uit dat bestand gelezen worden alsook in dat bestand geschreven worden. De klasse fstream erft zowel van ifstream als van ofstream via iostream (zie 6.3.1). In het volgende programma wordt eerst het getal 50 en de string “hello” geschreven in het bestand “C:\Luc\demo5”. Vervolgens wordt het getal 50 vervangen door het getal 60. Tenslotte wordt dat bestand gelezen en wordt de inhoud ervan (60 hello) op het scherm gezet. //programma P195.cpp #include #include void main() { int getal; char s[80]; fstream bestand(“C:\\Luc\\demo5”, ios::in|ios::out); bestand<<50<<endl; bestand<<”hello”<<endl; bestand.seekp(0); bestand<<60; bestand>>getal; bestand>>s; cout<
162

2) Een output file stream houdt altijd een interne pointer bij die de positie in de file aangeeft waar de data zal weggeschreven worden. De functie seekp() zet de pointer op een welbepaalde positie en laat aldus random access toegang toe naar de file. Met de opdracht bestand.seekp(0); wordt de file pointer op nul gezet. Dit betekent dat het schrijven in het bestand gebeurt vanaf het begin van dat bestand. De informatie die zich eventueel daar bevindt, wordt overschreven.

6.9.4 Random file access 6.9.4.1 Algemeen Random file access betekent op een willekeurige plaats in een bestand schrijven of lezen. Bij objecten van de klasse fstream kan zowel de functie seekg() als seekp() worden gebruikt omdat fstream erft van ifstream en van ofstream.

6.9.4.2 Beschikbare inputstream functies •

De functie seekg(i) zal de leespointer, die wijst naar het volgende karakter dat gelezen wordt in het bestand, herpositioneren op een andere plaats, namelijk op de plaats i vanaf het begin van de file, om vanaf die positie te lezen. De letter g in seekg staat voor get (invoer). Het argument is van het type long, zodat dit bytenummer zeer groot kan zijn. Voorbeeld: ifstream invoer(“demo1); invoer.seekg(10); // de leespointer, ook getpointer genoemd, wordt op positie // 10 in het bestand gezet, dit is 10 bytes vanaf het begin // van het bestand

•

De functie tellg() geeft de waarde terug van de filepointer behorend tot het bestand. Voorbeeld: long posget= bestand.tellg();

6.9.4.3 Beschikbare outputstream lidfuncties •

De functie seekp(i) zet de pointer op een welbepaalde positie in het bestand, namelijk op positie i, om vanaf die positie te schrijven. De letter p in seekp staat voor put (uitvoer). Het argument is van het type long, zodat dit bytenummer zeer groot kan zijn. Voorbeeld: ofstream uitvoer(“demo2”); uitvoer.seekp(5);

// de schrijfpointer, ook putpointer genoemd, wordt op // positie 5 in het bestand gezet, dit is 5 bytes vanaf het // begin van het bestand

•

De functie tellp() geeft de positie terug van de filepointer. Voorbeeld: long posput= bestand.tellp();


163

6.9.4.4 Tweede argument van seekg() en seekp() Een andere manier om met random access een willekeurige positie in een bestand aan te wijzen, is gebruik maken van de constanten beg (begin), cur (huidig) en end (einde) van de klasse ios. Bij de volgende drie aanroepen van seekg() telt ‘offset’ respectievelijk van het begin van de file, vanaf de huidige positie en vanaf het einde van de file. bestand.seekg(offset, ios::beg); bestand.seekg(offset, ios::cur); bestand.seekg(offset, ios::end); Het default argument is ios::beg. Bij opgave van ios::end, kan enkel door offset negatief te nemen, een bestaande positie binnen het bestand worden aangewezen.

6.10 Allerlei met bestanden 6.10.1 Een stream na de declaratie koppelen aan een bestand In bepaalde situaties mag een stream niet bij de declaratie aan een bestand worden gekoppeld. De lidfunctie open() koppelt een stream aan een bestand. De functie open() voor ofstream opent het bestand voor schrijven en de functie open() voor ifstream opent het bestand voor lezen. Volgend voorbeeld koppelt de ifstream aan het bestand ‘test’ en opent dat bestand voor lezen: fstream bestand; ... bestand.open(“test”, ios::in);

6.10.2 Een bestand sluiten Wanneer de programma-uitvoering de scope van de stream verlaat die aan het bestand gekoppeld is, zorgt de destructor van de stream ervoor dat het bestand gesloten wordt. Dit heeft als gevolg dat bij het beëindigen van een programma, alle openstaande bestanden automatisch worden gesloten. Algemeen wordt als goed programmeren beschouwd om een bestand te sluiten als het werk met dat bestand gedaan is. Een geopend bestand kan altijd worden gesloten met de lidfunctie close(). Voorbeeld: fstream bestand; ... bestand.open(“test”, ios::out); ... bestand.close();

164

6.10.3 Toevoegen aan einde bestand Volgende statements openen een bestand om de gegevens, die naar het bestand worden geschreven, toe te voegen aan het einde van dat bestand. Merk op dat dan de functie seekp() wordt uitgeschakeld. fstream bestand(“test”, ios::app | ios::out); of

ofstream bestand(“test”, ios::app);

Met ‘ios::app’ wordt een bestand geopend voor ‘appending’ (toevoegen aan het einde van het bestand).

6.10.4 Bestaand bestand openen en leeg maken •

De inhoud van het bestaande bestand ‘demo’ gaat in volgende gevallen verloren bij het openen van dat bestand. Het bestand ‘demo’ wordt dus leeg gemaakt. ofstream bestand(“demo”); fstream bestand(“demo”, ios::out); fstream bestand(“demo”, ios::in | ios::out);

•

In volgende gevallen wordt het bestaande bestand ‘test’ niet leeg gemaakt bij het openen ervan:

•

fstream bestand(“test”, ios::in);

// lezen uit bestand

ifstream bestand(“test”);

// lezen uit bestand

fstream bestand(“test”, ios::app | ios::out);

//toevoegen aan het einde

ofstream bestand(“test”, ios::app);

//toevoegen aan het einde

Door expliciet ‘ios::trunc’ op te geven, wordt een bestaand bestand leeg gemaakt. Voorbeeld: fstream bestand(“test”, ios::trunc|ios::in|ios::out); Het bestand ‘test’ wordt geopend voor lezen en schrijven, doch eerst wordt het leeg gemaakt.

6.10.5 Werken met een bestaand bestand Controleren of het bestand om mee te werken zeker reeds bestaat, kan met ‘ios::nocreate’. De functie faalt als het bestand niet bestaat. Voorbeeld: 1) fstream bestand(“test”, ios::nocreate|ios::out|ios::app); if (!bestand)

// test op de naam van de stream

{ // bestand ‘test’ bestaat ... } 2) fstream bestand(“test”, ios::nocreate|ios::out|ios::app); if (bestand.fail())

// test met lidfunctie van de stream

{ // bestand ‘test’ bestaat ... }


165

6.10.6 Niet werken met een bestaand bestand Met ‘ios::noreplace’ kan voorkomen worden dat een bestaand bestand wordt overschreven of gewijzigd. De functie faalt als het bestand niet bestaat. Voorbeeld: fstream bestand(“test”, ios::noreplace|ios::out|ios::app); if (!bestand)

// test op de naam van de stream

{ // bestand ‘test’ bestaat ... }

6.11 Binaire bestanden 6.11.1 Binair bestand versus tekstbestand •

Een tekstbestand is een bestand dat bestaat uit deeltjes tekst, die van elkaar gescheiden zijn door een scheidingsteken (spatie, tab, newline). Zowel woorden als getallen zijn tektst. Zo beslaat 1234 vier bytes in een tekstbestand. Een tekstbestand kan in een editor worden gelezen. Voordeel van een tekstbestand is dat het leesbaar is en dat de structuur helder is.

•

Een binair bestand is een bestand waarin de gegevens binair gecodeerd zijn. Een int-waarde wordt opgeslagen in twee bytes, en een double in acht bytes. In een binair bestand staan in het algemeen geen scheidingstekens tussen de verschillende waarden, alhoewel dat wel zou kunnen. Een binair bestand is meestal onleesbaar in een editor. Voordeel van een binair bestand is de mogelijkheid om grote stukken data in één keer te schrijven of te lezen. Zo kunnen objecten in één keer naar een binair bestand worden geschreven. Uiteraard worden enkel de waarde van de data-leden van een object naar het bestand geschreven, en dus niet de lidfuncties en friendfuncties.

•

Het is mogelijk een tekstbestand te behandelen als een binair bestand, omdat elk teken in een tekstbestand zijn eigen binaire code heeft. Zo is ‘0100 0001’de binaire code van de letter ‘A’.

6.11.2 Schrijven van een object naar een binair bestand Volgend programma schrijft de naam en het loon van werknemer W in het binair bestand ‘salaris’. //programma P196.cpp #include #include #include <string.h>

166

class Werknemer { private: char naam[40]; double loon; public: Werknemer(char* nm= “”, double ln= 0.0) { strcpy(naam, nm); loon= ln; } }; void main() { const char* bestandsnaam= “salaris”; Werknemer W(“Dirk”, 2010.65); ofstream uitvoer(bestandsnaam, ios::binary); if (!uitvoer) { cerr<<”Bestand kan niet geopend worden!”; return; } uitvoer.write((char*)&W, sizeof(Werknemer)); } Bespreking van het programma: 1) Een bestand wordt een binair bestand door bij het openen van dat bestand expliciet ‘ios::binary’ mee te geven. ofstream uitvoer(bestandsnaam, ios::binary); 2) De functie write() schrijft een blok geheugen weg naar de output file stream. Bij zo’n blok moet het adres van dat blok en het aantal bytes (grootte van dat blok) worden opgegeven. uitvoer.write((char*)&W, sizeof(Werknemer)); De functie write() heeft twee argumenten: -

een char* waarin het adres van het blok komt

-

een int voor de grootte van het blok

In het voorbeeld is het blok het object W van de klasse Werknemer. Het adres van W is uiteraard &W en met behulp van een cast wordt dit een char*. De grootte van het blok W wordt bepaald met sizeof(W), of meer algemeen met sizeof(Werknemer), omdat W een object is van de klasse Werknemer. Schrijven in een binair bestand kan ook karakter per karakter met behulp van de functie put(). Voorbeeld: uitvoer.put(‘a’); . 3) De stream cerr is een standaard stream zoals cin en cout. De stream cerr kan worden gebruikt voor de uitvoer van foutmeldingen, en is meestal gekoppeld aan het beeldscherm. T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

167

De stream clog is de gebufferde versie van cerr. Door clog aan een bestand te koppelen, gaan foutmeldingen niet naar het scherm, maar naar het gekoppelde bestand.

6.11.3 Lezen van een object uit een binair bestand Volgend programma leest de inhoud van het bestand ‘salaris’ en zet de inhoud op het beeldscherm. De inhoud van het bestand ‘salaris’ is een object van de klasse Werknemer. //programma P197.cpp #include #include #include <string.h> #include class Werknemer { private: char naam[40]; double loon; public: Werknemer(char* nm= “”, double ln= 0.0) { strcpy(naam, nm); loon= ln; } friend ostream& operator<<(ostream&, Werknemer&); }; ostream& operator<<(opstream& uitvoer, Werknemer& wknr) { return uitvoer << wknr.naam << ‘\t’ << setiosflags(ios::showpoint|ios::fixed) << setprecison(2) << wknr.loon; } void main() { const char* bestandsnaam= “salaris”; ifstream invoer(bestandsnaam, ios::binary); if (!invoer) { cerr<<”Bestand kan niet geopend worden!”; return; } Werknemer W; ofstream uitvoer(bestandsnaam, ios::binary); invoer.read((char*)&W, sizeof(Werknemer)); cout<<W<<endl; }

168

Bespreking van het programma: 1) In de klasse Werknemer is nu de friendfunctie operator<<() gedefinieerd om de inhoud van objecten naar het beeldscherm te kunnen schrijven. 2) De uitvoer van het programma is: Dirk

2010.65

3) De functie read() leest een heel blok, hier het object W, tegelijk uit het bestand. De functie read() heeft twee argumenten: -

het eerste argument is het adres in het geheugen waar het gelezen blok moet geplaatst worden

-

het tweede argument is de grootte van het blok

Lezen uit een binair bestand kan ook karakter per karakter met behulp van de functie get(). Voorbeeld:

invoer.get(karakter);

6.11.4 Lezen en schrijven van objecten via lidfuncties In een omgeving met objecten zijn lidfuncties voor het schrijven in en lezen uit een bestand interessant. Volgend programma maakt gebruik van de lidfunctie schrijf() om van twee werknemers hun naam en loon te bewaren in het bestand ‘salaris’. Met de functie lees() worden de gegevens uit het bestand ‘salaris’ gelezen. //programma P198.cpp #include #include #include <string.h> #include class Werknemer { private: char naam[40]; double loon; public: Werknemer(char* nm= “”, double ln= 0.0) { strcpy(naam, nm); loon= ln; } void schrijf(ostream &uitvoer) { uitvoer.write((char*) this, sizeof(*this)); } void lees(istream &invoer) { invoer.read((char*) this, sizeof(*this)); } friend ostream& operator<<(ostream&, Werknemer&); };


169

ostream& operator<<(opstream& uitvoer, Werknemer& wknr) { return uitvoer << wknr.naam << ‘\t’ << setiosflags(ios::showpoint|ios::fixed) << setprecison(2) << wknr.loon; } void main() { Werknemer w1[2]= { Werknemer(“Dirk”, 2010.65), Werknemer(“Els”, 1802.18) }; ofstream uitvoer(“salaris”, ios::binary); for (int i=0; i< 2; i++) w1[i].schrijf(uitvoer); uitvoer.close(); cout<<”De data is opgeslagen in het bestand. Verder= Enter”; cin.get(): ifstream invoer(“salaris”, ios::binary); if (!invoer) { cerr<<”Bestand kan niet geopend worden!”; return; } Werknemer w2[2]; int aantal= 0; w2[aantal].lees(invoer); while (invoer) { aantal++: if (aantal >= 2) break; w2[aantal].lees(invoer); } cout<<”Het bestand is gelezen. De inhoud is: “<<endl; for (int i=0; i< 2; i++) cout<<w2[i]<<endl; } Bespreking van het programma: 1) De functie schrijf() maakt gebruik van de lidfunctie write(). Het adres dat write() nodig heeft, is het adres van het object waarvan write() lidfunctie is. Dit adres is gegeven via de pointer this. 2) De functie lees() maakt gebruik van de lidfunctie read(). Het adres dat read() nodig heeft, wordt geleverd door de this-pointer.

170

6.11.5 Bijwerken van een bestand met gebruik van random access //programma P199.cpp #include #include #include <stdlib.h> fstream bestand; void tonen() { long x; bestand.seekg(0): for (;;) { bestand.read((char*)&x, sizeof(x)); if (bestand.eof() break; cout<<x<<endl; } bestand.clear(); } void controle(int c) { if (!bestand.good()) { cout<<endl; cout<<”Invoerfout of Uitvoerfout”<<endl; exit(1); } } void main() { long nt, i, x, incr; cout<<”Hoeveel getallen (long int) in bestand schrijven? “; cin>>nt; bestand.open(“Mijnbestand”, ios::in|ios::out|ios::binary|ios::trunc); controle(1); for (i= 0; i< nt; i++) { x= 10*i; bestand.write((char*)&x, sizeof(x)); controle(2); } tonen(); do { cout<<”Geef een positief geheel getal kleiner dan “<>i; while (i< 0 || i> nt); bestand.seekg(i*sizeof(i), ios::beg); bestand.read((char*)&x, sizeof(x)); T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

171

controle(3); cout<<x<<endl; cout<<”Verhogen met: “; cin>>incr; x+=incr; bestand.seekp(i*sizeof(i), ios::beg); bestand.write((char*)&x, sizeof(x)); controle(4); tonen(); } Uitvoering van het programma: Hoeveel getallen (long int) in bestand schrijven? 5 0 10 20 30 40 Geef een positief geheel getal kleiner dan 5: 2 20 Verhogen met: 6 0 10 26 30 40 Het intypen van 2 gaat over het derde getal (20), dat verhoogd wordt met 6.

6.12 Kopiëren van een bestand 6.12.1 Kopiëren van een bestand, byte per byte. Een bestand kan karakter per karakter gekopiëerd worden met behulp van de lidfuncties get() en put(). Volgend programma kopieert het bestand ‘salaris’ in ‘kopiesalaris’. //programma P200.cpp #include #include void main() { ifstream orgbestand(“salaris); ofstream kopiebestand(“kopiesalaris”); char ch; if (orgbestand && kopiebestand) while (orgbestand.get(ch)) kopiebestand.put(ch); }

172

De functie get() levert de waarde nul als het einde van het bestand is bereikt, anders een waarde verschillend van nul.

6.12.2 Kopiëren van een bestand met rdbuf() Elke stream maakt gebruik van een buffer om de gegevens van de stream tijdelijk op te slaan. Deze buffer is een object van de klasse streambuf, en de lidfunctie rdbuf() levert het adres van deze buffer op. Daar de operatoren << en >> overladen zijn voor een pointer naar streambuf, kan een bestand eenvoudig worden gekopieerd. Voorbeeld: Volgend programma kopieert het bestand ‘salaris’ in ‘kopiesalaris’: //programma P201.cpp #include void main() { ifstream orgbestand(“salaris”, ios::binary); ofstream kopiebestand(“kopiesalaris”, ios::binary); orgbestand >> kopiebestand.rdbuf(); } De stream orgbestand stuurt alle gegevens van het bestand salaris naar de buffer van de stream uitvoer. Beide bestanden moeten als binair bestand worden geopend. In plaats van orgbestand >> kopiebestand.rdbuf(); mag ook de gespiegelde opdracht gebruikt worden: kopiebestand << orgbestand.rdbuf();

6.12.3 Kopiëren van een bestand naar het beeldscherm Via de buffer van de standaard stream cout kan de inhoud van een tekstbestand op het beeldscherm worden gezet. Voorbeeld: //programma P202.cpp #include #include void main() { ifstream orgbestand(“salaris”, ios::binary); cout<> cout.rdbuf();


173

6.12.4 Kopiëren van een bestand naar de printer De uitvoer van een programma kan naar de printer worden gestuurd door de printer aan een stream te koppelen. Voorbeeld: //programma P203.cpp #include #include void main() { ifstream invoer(“salaris”, ios::binary); ofstream printer(“PRN”); printer<
//of: invoer>>printer.rdbuf();

}

6.13 Oefeningen 1) Declareer een array voor vier datums. Een datum is een object van de klasse Datum met de data-leden dag, maand en jaar. Schrijf de vier datums weg in een bestand. 2) Schrijf een programma om de datums in vorig bestand te lezen en ze op het scherm te zetten volgens het formaat ‘dd/mm/yyyy’.

174

7. Classes 7.1 De MFC-bibliotheek 7.1.1 Algemeen De Microsoft Foundations Classes (MFC) bibliotheek is de C++ bibliotheek die standaard bij Microsoft Visual C++ geleverd wordt. De MFC-bibliotheek levert allerlei klassen die kunnen aangewend worden in zowel DOS- als WINDOWS-omgeving. In de MFC-bibliotheek zijn er een aantal klassen die strings, files en arrays implementeren.

7.1.2 Groepen klassen Men onderscheidt drie groepen klassen: 1) De klassen die naar een file (CFile) schrijven. Dit kan een gewone file (CStdioFile) zijn, maar ook een virtuele file in het geheugen (CMemFile) zijn. Schematisch: CObject CFile CStdioFile CMemFile 2) De klassen die exceptions (CExceptions) behandelen. Schematisch: CObject CExceptions CMemoryException CFileException CArchiveException CUserException 3) De collection classes, die allerlei groepen van objecten kunnen bewaren. Schematisch: CObject CByteArray CWordArray CStringArray CStringList


175

Naast de drie groepen zijn er nog een aantal losstaande klassen die bijvoorbeeld strings (CString) of datums (CTime) implementeren.

7.2 De CObject-klasse 7.2.1 De CObject-klasse De basis van de MFC-bibliotheek wordt gevormd door de CObject-klasse. Met andere woorden, de CObject-klasse vormt de basis voor alle andere MFC-klassen. De CObject-klasse is een abstracte klasse die bepaalde basisfunctionaliteiten bezit. Die basiseigenschappen kunnen worden overgeërd door de afgeleide klassen van CObject.

7.2.2 Basiseigenschappen van de CObject-klasse De basiseigenschappen van de CObject-klasse zijn onder andere: •

runtime class information Indien een afgeleide klasse deze eigenschap overerft, dan zal een object van die afgeleide klasse kunnen bepalen tot welke klasse hij behoort, en dat tijdens de uitvoering van het programma.

•

serializatie Deze eigenschap laat toe om een volledig object weg te schrijven naar de harde schijf, om deze dan eventueel later weer in te lezen in een ander object.

7.3 De CFile-klasse 7.3.1 Files 7.3.1.1 De CFile-klasse De CFile-klasse zorgt voor niet-gebufferde, binaire disk I/O. De CFile-klasse wordt gewoonlijk gebruikt voor het wegschrijven van binaire gegevens, en niet zozeer voor tekst. In die zin verschilt de CFile-klasse dan ook van de iostream-bibliotheek.

7.3.1.2 Afgeleide klassen van CFile De klassen CStdioFile en CMemFile zijn afgeleide klassen van CFile. •

De klasse CStdioFile supporteert tekstfiles. Deze klasse werkt analoog als de Cfunctie fopen(). CStdioFile maakt gebufferde input/output mogelijk naar een file, en gaat (default) een conversie doen van ‘newline’ naar ‘carriage return/linefeed’.

•

De klasse CMemFile supporteert geheugenfiles. Deze klasse is identiek aan de klasse CFile, behalve dat de file-inhoud niet wordt weggeschreven naar een vaste schijf, maar naar een blok geheugen. Dit blok geheugen wordt automatisch gealloceerd en vergroot naarmate de ‘geheugenfile’ groter wordt. Bij wissen van het object wordt het geheugenblok dat de file-inhoud bevat, ook automatisch gewist.

176

7.3.1.3 Voorbeeld Volgend programma schrijft eerst de inhoud van de structuurvariabele EenDatum weg naar het bestand ‘datum.dat’. Vervolgens wordt de inhoud van die file gelezen in de structuurvariabele NieuweDatum en op het scherm gebracht. Uiteraard is de inhoud van NieuweDatum gelijk aan de inhoud van EenDatum. //programma P204.cpp #include #include typedef struct datum_str { int dag; int maand; int jaar; } Datum; void main() { char *pBestandsnaam= “datum.dat”; CFile datumfile; Datum EenDatum= {20, 10, 2002}; if (!datumfile.Open(pBestandsnaam, CFile::modeCreate|CFile::modeReadWrite))

// 1)

{ cout << “De file “ << pBestandsnaam << “ kan niet gopend worden.” << endl; exit(-1); } datumfile.Write(&EenDatum, sizeof(EenDatum)); datumfile.Seek(0, CFile::begn);

// 2)

// 3)

Datum NieuweDatum; datumfile.Read(&NieuweDatum, sizeof(NieuweDatum));

// 4)

cout << “Nieuwe datum: “ << endl; cout <<”

dag: “ << NieuweDatum.dag << endl;

cout <<”

maand: “ << NieuweDatum.maand << endl;

cout <<”

jaar: “ << NieuweDatum.jaar << endl;

datumfile.Close(); } De uitvoer van het programma is: Nieuwe datum: dag: 20 maand: 10 jaar: 2002


177

Bespreking van het programma: 1) De lidfunctie Open() van het object datumfile van de klasse CFile wordt aangeroepen met het te openen bestand aangewezen met pBestandsnaam, en met de vlaggen modeCreate en modeReadWrite. De vlag modeCreate creëert het bestand aangewezen met pBestandsnaam en de vlag modeReadWrite opent dat bestand voor lezen en schrijven. 2) Het volledige geheugenblok, ingenomen door de structuurvariabele EenDatum wordt weggeschreven naar het bestand datum.dat. 3) De lidfunctie Seek() zet de filepointer terug aan het begin van het bestand datum.dat. 4) De inhoud van het bestand datum.dat wordt gelezen in de nieuw aangemaakte structuurvariabele NieuweDatum.

7.3.2 Serializatie van objecten 7.3.2.1 Serializatie van een object Serializatie van een object betekent het wegschrijven van de inhoud van de dataleden van dat object naar een bestand. Dit is analoog met vorig programma, doch bij serializatie gaat het over objecten, in plaats van over structuurvariabelen. Wanneer een object ‘geserializeerd’ wordt, dan wordt zijn huidige inhoud weggeschreven naar de vaste schijf. Later kan dat object terug opgehaald worden met hetzelfde mechanisme van serializatie. In OO-terminologie betekent dit het vastleggen van de toestand van het object op de vaste schijf. Voorbeeld: Het programma ‘vluchtsimulator’ moet de gebruiker de mogelijkheid bieden om de huidige spelsituatie te onderbreken en te bewaren op vaste schijf, om dan later vanuit de huidige toestand het spel te kunnen verder zetten.

7.3.2.2 Een klasse serializeerbaar maken Voor het serializeren van een object zijn er twee basisvoorwaarden vereist: 1) Het object moet behoren tot een afgeleide klasse van CObject. 2) Een speciale lidfunctie voor de te serializeren klasse. Die lidfunctie moet effectief alle data-leden van het betreffende object wegschrijven. Daartoe maakt die lidfunctie gebruik van de klasse CArchive. Bovendien moeten bepaalde macro’s worden aangeroepen. Deze macro’s zorgen ervoor dat de nodige functionaliteit wordt overgeërfd van de klasse CObject. Concreet moeten volgende stappen doorlopen worden om een klasse serializeerbaar te maken: 1) Leid de klasse af van de klasse CObject en gebruik de macro DECLARE_SERIAL in de beschrijving van de klasse.

178

De klasse-declaratie zal er dus als volgt uitzien: class EenKlasse : public CObject { DECLARE_SERIAL(EenKlasse) // rest van de beschrijving }; 2) Voeg de lidfunctie Serialize toe aan de klasse. Deze Serialize-functie heeft als argument altijd een object behorend tot de klasse CArchive. De klasse-declaratie wordt: #include class EenKlasse : public CObject { public: DECLARE_SERIAL(EenKlasse) WORD element1, element2; EenKlasse() {}; EenKlasse(int e1, int e2) { element1= e1; element2= e2; } void Serialize(CArchive& archive); // rest van de klasse-declaratie }; De functie Serialize() is reeds gedefinieerd in de klasse CObject. In de afgeleide klasse wordt deze functie opnieuw gedefinieerd. Dit betekent: -

de functie Serialize() in de basisklasse zorgt ervoor dat de elementen van de basisklasse worden weggeschreven naar de harde schijf;

-

de functie Serialize() in de afgeleide klasse zorgt ervoor dat de dataelementen van de afgeleide klasse worden weggeschreven naar de harde schijf.

Dit houdt het volgende in voor de implementatie van de functie Serialize(): -

de functie Serialize() van de basisklasse moet worden aangeroepen zodat de elementen van de basisklasse worden weggeschreven;

-

elk data-element van de afgeleide klasse moet worden weggeschreven naar de harde schijf met behulp van de operator ‘<<’. Lezen van de harde schijf moet gebeuren met behulp van de operator ‘>>’.

Een typische Serialize-functie ziet er als volgt uit: void EenKlasse :: Serialize(CArchive& archive) { //eerst aanroepen van de Serialize-functie van de basisklasse CObject :: Serialize(archive); //stockeer vervolgens element per element van de afgeleide klasse T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

179

if (archive.IsStoring()) { archive << element1 << element2; } else { archive >> element2 >> element2; } } 3) Bij het deserializeren van de objecten, die zijn opgeslagen op de vaste schijf, moet elk object opnieuw worden aangemaakt en de waarden van de data-leden moeten worden geïnitialiseerd. De MFC-functies die dit werkje uitvoeren hebben hiervoor wel een default constructor nodig. Dit betekent dat elke klasse, die moet geserializeerd worden, moet voorzien zijn van een default constructor (= een constructor zonder argumenten). 4) Tenslotte moet in de file, waarin de lidfuncties zijn opgeslagen, een macro worden aangeroepen die de noodzakelijke functies bevat voor het implementeren van het serializatie-proces. Die macro heeft volgende syntax: IMPLEMENT_SERIAL(EenKlasse, CObject, 1) De drie argumenten zijn: -

de naam van de klasse, die moet geserializeerd worden

-

de basisklasse van de te serializeren klasse

-

een getal (‘serieel nummer’) dat uniek de klasse definieert, die wordt geserializeerd. Dit serieel nummer wordt geverifieerd telkens een object van de harde schijf wordt gehaald. Indien het serieel nummer van het object op de harde schijf niet overeenkomt met hetgaan verwacht wordt, zal een fout worden gegenereerd.

7.3.2.3 Het serializeren van een object Na het aanmaken van de te serializeren klasse, kunnen de objecten worden geschreven naar of worden gelezen van de harde schijf. Dit is het serializeren van de objecten. Het serializeren van een object vereist het aanwenden van de klassen CArchive en CFile: -

CArchive zorgt ervoor dat een object effectief ‘geserializeerd’ wordt naar de harde schijf;

-

CFile representeert de file waarnaar geschreven of waaruit gelezen wordt.

Het volgende voorbeeld demonstreert het serializeren van een object. //programma P205.cpp #include void LeesObject(EenKlasse **pEenObj, char *pBestandsnaam);

// 1)

void StockeerObject(EenKlasse **pEenObj, char *pBestandsnaam);

// 2)

180

void main() { char *Bestandsnaam= “serfile.dat”; EenKlasse *pEenObj= new EenKlasse(2, 3); cout << “Elementen van het object: “ << pEenObj -> element1 << pEenObj -> element2 << endl; StockeerObject(pEenObj, Bestandsnaam);

// 3) + 4)

EenKlasse *pNieuwObj= NULL; LeesObject(&pNieuwObj, Bestandsnaam); cout << “Elementen van het nieuwe object: “ << pNieuwObj -> element1 << pNieuwObj -> element2 << endl; } void LeesObject(EenKlasse **pEenObj, char *pBestandsnaam) { CFile objectfile; if (!objectfile.Open(pBestandsnaam, CFile::modeRead)) { cout << “Leesobject: kan bestand “ << pBestandsnaam << “ niet openen.” << endl; exit(1); } CArchive InArchive (&objectfile, CArchive::load); InArchive >> *pEenObj; InArchive.Close(); objectfile.Close(); } void StockeerObject(EenKlasse **pEenObj, char *pBestandsnaam) { CFile objectfile; if (!objectfile.Open(pBestandsnaam, CFile::modeCreate|CFile::modeWrite)) {

// 3)

cout << “Stockeerobject: kan bestand “ << pBestandsnaam << “ niet openen.” << endl; exit(1); } CArchive OutArchive (&objectfile, CArchive::store); OutArchive >> *pEenObj;

// 4)

// 4)

OutArchive.Close(); objectfile.Close(); } Bespreking: Algemeen: Er moet altijd gewerkt worden via een CFile-object om naar een file te schrijven of uit een file te lezen. Er kan dus geen gebruik worden gemaakt van de iostream-bibliotheek om een file te openen. 1) De functie LeesObject() dient voor het lezen van het object. 2) De functie StockeerObject() dient voor het wegschrijven van het object. T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

181

3) De functie StockeerObject() opent met behulp van het CFile-object ‘objectfile’ het bestand ‘serfile.dat’ om te schrijven. 4) De lidfunctie ‘OutArchive’ is van de klasse CArchive. De opdracht ‘OutArchive<<*pEenObj’ schrijft effectief het object, aangewezen door pEenObj, weg naar de harde schijf in de file ‘serfile.dat’. De lidfunctie OutArchive maakt gebruik van het argument &objectfile. Daar objectfile een CFile-object is, ontstaat er dus een rechtstreekse koppeling tussen CArchive en CFile. Het object aangewezen door de pointer pEenObj wordt weggeschreven met behulp van de operator >>. 5) De functie LeesObject() opent het bestand ‘serfile.dat’ om te lezen en zal ook het gestockeerde object deserialezeren.

7.4 De CException-klasse 7.4.1 Exceptions Elk programma heeft te maken met externe factoren die ervoor kunnen zorgen dat het programma niet functioneert zoals het hoort. Enkele voorbeelden: •

openen van een niet bestaande schijf

•

onvoldoende vrije ruimte op schijf

•

delen door nul

•

onvoldoend vrij dynamische geheugen

•

diskette is defect

•

diskette is beveiligd tegen schrijven

In al deze gevallen zal het programma op een correcte manier moeten reageren om te vermijden dat het programma foutieve resultaten produceert, of in het ergste geval ‘crasht’, indien zo’n ‘exceptionele’ (uitzonderlijke) gebeurtenis plaatsvindt. Het probleem is dat de programmeur dan praktisch bij elk codefragment bijkomende code moet toevoegen die de juiste correctieve acties uitvoert, of de gebruiker informeert wanneer een fout is opgetreden. Dit maakt het programma gewoonlijk een stuk minder leesbaar, omdat de normale code vermengd wordt met code die bepaalde exceptions behandelt. Daarentegen wordt de leesbaarheid grotendeels bevorderd indien alle ‘uitzonderingen’ in een wel bepaald codefragment worden geplaatst, goed afgescheiden van de normale uitvoerbare code. Daar deze problematiek niet met de huidige C++ taalconstructies op een elegante manier kan worden opgelost, zijn ‘exceptions’ toegevoegd aan de taal om onverwachte gebeurtenissen bij de programma-uitvoering op een elegante manier af te handelen. Een andere benaming voor ‘exception’ (exceptie) is ‘exception handling’ (exceptie afhandeling). Exceptions kunnen beschouwd worden als code die de normale uitvoering van het programma onderbreekt en specifieke code uitvoert, bijvoorbeeld om de gebruiker te informeren over de opgetreden fout.

182

De exceptions maken deel uit van de MFC-bibliotheek en zijn dus niet in de taal C++ verweven. In C++ wordt een exception gedefinieerd als een C++ object dat vanuit de code, waar de exceptionele gebeurtenis plaats heeft, gestuurd wordt naar een ander stuk code, dat verantwoordelijk is voor het afhandelen van die exceptionele gebeurtenis. Het type van exceptie en dus het corresponderende object dat uitgestuurd wordt, bepaalt welk stuk code het probleem zal afhandelen. De filosofie achter exceptions is de volgende: •

Gewoonlijk zal een exception gegenereerd worden in een codefragment op een laag niveau.

•

De code die een exceptie moet afhandelen, bijvoorbeeld de gebruiker waarschuwen van het probleem, of een correctieve actie uitvoeren, is gewoonlijk gelocaliseerd op een hoog niveau in de code.

•

Exceptions zorgen ervoor dat een bepaald type van exceptie wordt ‘getransporteerd’ van de plaats waar de exceptie werd gegenereerd naar de plaats waar de exceptie wordt afgehandeld.

7.4.2 Werking van exception handling Exception handling maakt gebruik van volgende sleutelwoorden: try

: probeer iets uit

throw

: als het mis gaat, werp dan een exceptie

catch

: vang de exceptie ergens op

Volgend voorbeeld demonstreert hoe exception handling werkt. //programma P206.cpp #include double deling(int deeltal, int deler) { if (deler == 0) throw 0; return double(deeltal)/deler; } void main() { double quotient; try { quotient= deling(14, 4); cout << quotient << endl; quotient= deling(10, 0); cout << quotient << endl; } catch { cout << “Delen door nul kan niet!”; } }


183

Bespreking van het programma: 1) In main() staat een try-blok. Dit is het gedeelte vanaf het sleutelwoord ‘try’ tot de afsluitaccolade van het catch-gedeelte. Een try-blok omvat altijd een try-gedeelte en een catch-gedeelte. Het catchgedeelte heet een ‘exception handler’, of kortweg ‘handler’. Er kan meer dan één handler voorkomen in een try-blok. Alle handlers bij mekaar vormen een handler-list. 2) Bij uitvoering van quotient= deling(10, 0); treedt de fout op bij delen door nul. Bij optreden van de fout werpt de functie deling() de exceptie if (deler == 0) throw 0; . De uitvoering van de functie wordt meteen onderbroken en de exceptie wordt opgevangen door de handler van het try-blok. Het gevolg is dat het statement return double(deeltal)/deler; niet wordt uitgevoerd. De uitvoer van het programma is: 3.50 Delen door nul kan niet! 3) Het type van exceptie is int, namelijk: -

in ‘throw 0’ wordt de int-waarde 0 afgeleverd (geworpen of gegooid)

-

catch(int) vangt de waarde 0 op.

7.4.3 Exception handling met verschillende types Het exception-mechanisme laat elk type, ook het type class, toe als exceptie en kan elk type exceptie afzonderlijk opvangen. Volgend voorbeeld maakt de som van twee int-getallen en vangt volgende uitzonderingen op: •

de som van twee positieve int-getallen is groter dan 32767

•

de som van twee negatieve int-getallen is kleiner dan –32768

Het programma maakt gebruik van de exceptionklassen TeGrootPos en TeGrootNeg. Verder heeft de try-blok een handler-list, die bestaat uit twee catchgedeelten. //programma P207.cpp class TeGrootPos {}; class TeGrootNeg {}; const int Maxint= 32767; int optelling(int getal1, int getal2); void main() { int som; try { som= optelling(Maxint, 25); cout << “De som = “ << som << endl; }

184

catch(TeGrootPos) { cerr << “De int-som is groter dan 32767 “ <<” en dit kan niet !”; } catch(TeGrootNeg) { cerr << “De int-som is kleiner dan -32768 “ <<” en dit kan niet !”; } } int optelling(int getal1, int getal2) { if (getal1 > 0 && getal2 > 0 && getal1 > Maxint – getal2) throw TeGrootPos(); if (getal1 < 0 && getal2 < 0 && getal1 < -Maxint - 1 – getal2) throw TeGrootNeg(); return (getal1 + getal2); } Bespreking van het programma: 1) De klassen TeGrootPos en TeGrootNeg zijn lege klassen. De enige bedoeling van deze klassen is het aanduiden van het type van exceptie. De code throw TeGrootPos() roept de default constructor van de klasse TeGrootPos aan om een tijdelijk TeGrootPos-object aan te maken. Dit object wordt opgevangen in het overeenkomstige catch-gedeelte in de handler-list. Als de som van de twee getallen groter is dan 32767, wordt er een TeGrootPosexceptie ‘gegooid’. Deze exceptie wordt opgevangen binnen main() in het catch-blok. Dit blok brengt een bericht op het beeldscherm dat de gebruiker informeert dat de som te groot is. Bij het genereren van een exceptie wordt de huidige programma-uitvoering onderbroken en springt de programma-uitvoering naar het catch-blok, zodat de code na de throw niet wordt uitgevoerd. 2) Als de optelling van twee positieve int-getallen groter is dan 32767, dan levert de optelling een negatieve waarde op. Om dit op te vangen kan een functie geschreven worden die, alvorens de optelling uit te voeren, eerst controleert of het resultaat niet te groot is. Indien wel, kan de functie een exceptie afleveren (gooien). Die controle kan niet met if ((getal1 + getal2) > 32767) omdat vóór uitvoering van de relationele operator >, reeds de bewerking (getal1 + getal2) een foutieve negatieve waarde oplevert. De controle moet zijn: if (getal1 > 32767 – getal2) T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

185

Omdat een aantal compilers de waarde –32768 niet als een geldige int-waarde accepteren, wordt de controle voor de som van twee negatieve getallen: if (getal1 > -32767 – 1 – getal2)

7.4.4 Definiëren van een exceptie in een klasse Excepties definiëren in een klasse is zinvol wanneer die excepties specifiek zijn voor die klasse. Volgend voorbeeld maakt gebruik van de klasse IntGetal met in de klasse de definitie van de excepties TeGrootPos en TeGrootNeg. //programma P208.cpp #include class IntGetal { private: int getal; public: class TeGrootPos {}; class TeGrootNeg {}; IntGetal :: operator+(IntGetal x) { if (this -> getal > 32767 – x.getal) throw TeGrootPos(); if (this -> getal < -32767 – 1 – x.getal) throw TeGrootNeg(); return IntGetal(getal + x); } }; void main() { IntGetal som; try { som= 32767 + 25; cout << “De som = “ << som << endl; } catch(IntGetal::TeGrootPos) { cerr << “De int-som is groter dan 32767 “ <<” en dit kan niet !”; } catch(IntGetal::TeGrootNeg) { cerr << “De int-som is kleiner dan -32768 “ <<” en dit kan niet !”; } }

186

7.4.5 Exception-klasse met informatie Excepties worden gevangen op basis van hun type. De afgeleverde exceptie is de waarde van een standaard type of is een object. In een object kan informatie geplaatst worden, die gebruikt kan worden in de handler die het object vangt. Volgend voorbeeld maakt de int-som van de int-getallen getal1 en getal2. Als de int-som echter groter is dan 32767 of kleiner is dan –32768, wordt de waarde van getal1 en getal2 via een constructor in de exceptie gestopt, zodat de exceptie kan tonen om welke getallen het gaat. //programma P209.cpp #include const int Maxint= 32767; class TeGrootPos

//exception-klasse met info

{ public: int x; int y; TeGrootPos(int g1, int g2)

//constructor

{ x= g1; y= g2; } }; class TeGrootNeg

//exception-klasse met info

{ public: int x; int y; TeGrootNeg(int g1, int g2)

//constructor

{ x= g1; y= g2; } }; int optelling(int getal1, int getal2); void main() { int som; try { som= optelling(1025, 25); cout << “De intsom = “ << som << endl; som= optelling(Maxint, 25); cout << “De intsom = “ << som << endl; } T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

187

catch(TeGrootPos g) { cerr << “De intsom van “ << g.x << “ + “ << g.y << “ is groter dan 32767 “ <<” en dit kan niet !” << endl; } catch(TeGrootNeg g) { cerr << “De intsom van “ << g.x << “ + “ << g.y << “ is kleiner dan -32768 “ <<” en dit kan niet !” << endl; } } int optelling(int getal1, int getal2) { if (getal1 > 0 && getal2 > 0 && getal1 > Maxint – getal2) throw TeGrootPos(getal1, getal2); if (getal1 < 0 && getal2 < 0 && getal1 < -Maxint - 1 – getal2) throw TeGrootNeg(getal1, getal2); return (getal1 + getal2); }

7.4.6 Het exception mechanisme Het sleutelwoord throw gooit een exceptie, wat leidt tot het uitvoeren van volgende stappen: 1) De huidige uitvoering van het programma wordt onderbroken. 2) Het object, zoals gespecificeerd in de throw()-instructie, wordt geconstrueerd als een tijdelijk object. 3) De programma-uitvoering springt naar het eerste try-blok hogerop in de hiërarchie van aanroepende functies, dat een catch-blok heeft dat correspondeert met het type van object dat gegenereerd wordt in de throw()instructie. 4) Wanneer gesprongen wordt naar het eerste try-blok, worden alle stackvariabelen die gecreëerd zijn geweest in het pad van het try-blok tot aan de throw()-instructie, vernietigd. Dit betekent dat voor al deze variabelen de destructor wordt opgeroepen. Dit noemt men het principe van ‘stack unwinding’. 5) Het tijdelijk object, dat de exceptie representeert, kan gebruikt worden binnen het catch-blok om eventueel informatie in te winnen over de gegenereerde exceptie. 6) Indien het eerste try-blok geen corresponderend catch-blok bevat, zal gezocht worden naar een hogerliggend try-blok dat wel een corresponderend catch-blok bevat. 7) Indien het programma geen enkel catch-blok heeft met het type van de gegenereerde exceptie, wordt het programma gestopt met de melding ‘abnormal program termination’.

188

Volgend voorbeeld demonstreert het exception mechanisme. //programma P210.cpp #include class EenKlasse { public: EenKlasse(char *String):str(String) { cout<<”constructor uitgevoerd voor “<<str<<endl; } ~EenKlasse() { cout<<”deconstructor uitgevoerd voor “<<str<<endl; } private: char *str; }; void functie2() { EenKlasse obj2(“object in functie2”); cout<<”Deze code wordt uitgevoerd”<<endl; throw(“String exceptie in functie2”); cout<<”Deze code wordt niet uitgevoerd”<<endl; } void functie1() { EenKlasse obj1(“object in functie1”); try { functie2(); } catch(char CharException) { cout<<”Gegenereerde char exceptie: “<
189

De uitvoer van dit programma is: constructor uitgevoerd voor object in functie1 constructor uitgevoerd voor object in functie2 Deze code wordt uitgevoerd destructor uitgevoerd voor object in functie2 destructor uitgevoerd voor object in functie1 Gegenereerde string exceptie: String exceptie in functie2 Bespreking van het programma: 1) In het try-blok van main() wordt bij aanroep van functie1() eerst het object obj1 van de klasse EenKlasse gecreëerd via volgende constructor: EenKlasse(char *String):str(String) { cout<<”constructor uitgevoerd voor “<<str<<endl; } Hierbij wordt de string “object in functie1” toegekend aan het private lid ‘str’ van EenKlasse. Het resultaat van die constructor is: constructor uitgevoerd voor object in functie1 2) Vervolgens wordt het try-blok van functie1() uitgevoerd, namelijk: functie2() wordt aangeroepen. -

In functie2() wordt eerst obj2 van EenKlasse gecreëerd via de constructor van EenKlasse. Het resultaat van de constructor is: constructor uitgevoerd voor object in functie2

-

Vervolgens wordt in functie2() de string “Deze code wordt uitgevoerd” op het beeldscherm gezet.

-

Daarna volgt throw(“String exceptie in functie2”); Dit betekent dat het programma een ‘char*’ exceptie gooit. Het gevolg van de geworpen ‘char*’ exceptie is: # de functies functie2() en functie1() worden verlaten; # de objecten obj1 en obj2 worden vernietigd en hun destructor wordt uitgevoerd. Op het scherm komt: destructor uitgevoerd voor object in functie2 destructor uitgevoerd voor object in functie1 # in functie1() wordt geen catch-blok uitgevoerd omdat geen van beide blokken correspondeert met een char *exception; # het char *-object in het catch-blok in main() wordt gebruikt om bijkomende info te verschaffen over de exceptie: Gegenereerde string exceptie: String exceptie in functie2

7.4.7 Teruggooien van een reeds opgevangen exceptie 7.4.7.1 Re-throw Het is mogelijk om in een catch-blok een opgevangen exceptie opnieuw te ‘gooien’. Dit betekent dat de exceptie eerst wordt behandeld in een catch-blok in een lager

190

gelegen functie, en dan wordt doorgegeven naar een hoger gelegen catch-blok. Dit heet re-throw. Een re-throw gebeurt door het aanroepen van de throw-instructie zonder parameters. Bij een re-throw wordt automatisch exact dezelfde exceptie geworpen als de exceptie die opgevangen werd.

7.4.7.2 Voorbeeld In volgend voorbeeld wordt eerst functie f1() aangeroepen, die op haar beurt functie f2() aanroept. Functie f2() gooit de exceptie “Iets niet in orde !”. Die geworpen exceptie wordt opgevangen in de handler ‘catch(const char *) van functie f1(). Deze handler zet op het scherm “In functie f1() opgevangen: Iets niet in orde !” en werpt vervolgens de exceptie opnieuw. Die exceptie wordt nu opgevangen door de handler in main(). Die handler zet op het scherm: “In main() opgevangen: Iets niet in orde ! . //programma P211.cpp #include void f1(); void f2(); void f1() { try { f2(); } catch(const char *s) { cerr<<”In functie f1() opgevangen: “<< s <<endl; throw; } } void f2() { //. . . functie f2() is niet in orde throw “Iets niet in orde !” } void main() { try { f1(); } catch(const char *s) { cerr<<”In main() opgevangen: “<< s <<endl; } }


191

7.4.8 Het voorkomen van geheugenlekken bij excepties 7.4.8.1 Geheugenlekken Bij het gebruik van excepties bestaat het gevaar dat er onbewust geheugenlekken kunnen optreden wanneer een exceptie gegenereerd wordt. Dit is het geval als er dynamisch geheugen wordt gereserveerd voor een object en dat dit object niet volledige geconstrueerd wordt, omdat tijdens de constructie een exceptie optreedt. Aldus wordt het toegewezen geheugen nooit vrijgegeven. Dit is ‘geheugenlekken’ (E: memory leakage). Indien in de volgende functie ‘Eenfunctie()’ de functie InitArray() een exceptie genereert, dan wordt de uitvoering van Eenfunctie() onderbroken en zal het geheugen, aangewezen door p, nooit vrijgegeven worden. Immers, de opdracht ‘delete[] p’ wordt niet uitgevoerd. void Eenfunctie() { char *p= new char[40]; InitArray(p); delete[] p; }

7.4.8.2 De ‘catch all’ instructie Volgend codefragment voorkomt het geheugenlekken. Hierbij wordt gebruik gemaakt van de ‘catch all’ instructie catch(…), die elk soort exceptie kan opvangen. Dit laat toe om bij iedere exceptie het geheugen vrij te geven. Omdat de exceptie op een hoger niveau moet worden afgehandeld, wordt throw opgeroepen, die de exceptie opnieuw genereert. void Eenfunctie() { char *p= new char[40]; try { InitArray(p); } catch(…) { delete[] p; throw; } delete[] p; } De drie puntjes in catch(…) heten een ellips (E: ellipsis). De ellips accepteert elke exceptie die niet door een andere handler in de handler-list kan worden opgevangen.

192

7.5 Containers 7.5.1 Containerklasse 7.5.1.1 Wat is een containerklasse? Een containerklasse is een klasse die één of meer objecten van andere klassen bevat. Als in de containerklasse een object van een andere klasse (het subobject) wordt gedeclareerd, ontstaat er een relatie tussen de containerklasse en de klasse van het subobject.

7.5.1.2 Voorbeeld van containerklasse Volgend voorbeeld gebruikt de containerklasse Artikel, waarin het object inkoopdatum van de klasse Datum wordt gedeclareerd. Dit betekent dat bij het maken van een object van de klasse Artikel, ook een object Datum wordt gemaakt. Voor het object Datum wordt de constructor van Datum aangeroepen, hier de default constructor. //programma P212.cpp #include #include #include <string.h> class Datum { private: int dag, maand, jaar; public: Datum(int d= 0, int m= 0, int j= 0); void invoeren(); void tonen(); }; Datum :: Datum(int d, int m, int j) { dag= d; maand= m; jaar= j; } void Datum :: invoeren() { cout << “Inkoopdatum: “ << endl; cout <<” dag: “; cin >> dag; cout <<” maand: “; cin >> maand; cout <<” jaar: “; cin >> jaar; }


193

void Datum :: tonen() { cout << setfill(‘0’) << setw(2) << dag << ‘/’ << setw(2) << maand << ‘/’ << setw(4) << jaar << endl; } class Artikel { private: char code[12]; Datum inkoopdatum; public: void invoeren(); void tonen(); }; void Artikel :: invoeren() { cout << “code: “ ; cin >> code; inkoopdatum.invoeren(); } void Artikel :: tonen() { cout << “De inkoopdatum van artikel met code “ << code << “ is “; inkoopdatum.tonen(); cout << endl; } void main() { Artikel art; art.invoeren(); art.tonen(); }

7.5.1.3 Containerklasse versus afgeleide klasse Een afgeleide klasse erft van zijn basisklassen. Een object van de afgeleide klasse staat in een ‘is een’-relatie tot zijn basisklasse. Voorbeeld: een elektrisch toestel ‘is een’ artikel. Wanneer daarentegen de relatie tussen twee objecten kan uitgedrukt worden met ‘heeft een’, zoals bijvoorbeeld ‘een artikel heeft een inkoopdatum’, dan maakt het ene object (inkoopdatum) deel uit van het andere object (artikel). Artikel is een containerklasse.

194

7.5.2 STL-bibliotheek 7.5.2.1 Algemeen De standaard C++ bibliotheek is een uitgebreide bibliotheek van klassen en functies die gebaseerd is op de mogelijkheden van de C++ taal. Een belangrijk onderdeel van de standaard C++ bibliotheek is de STL-bibliotheek. STL staat voor Standard Template Library. De STL-bibliotheek bevat: 1) Containers Containers zijn klassen die objecten op een welbepaalde manier stockeren. Het zijn dus opslagplaatsen van objecten. De manier van stockeren verschilt volgens het type container. Zo zal een vector-container de objecten sequentieel opslaan, en zal een list-container de objecten opslaan als een gelinkte lijst. Een container is dus een object dat gebruikt wordt om andere objecten te beheren. Een container voorziet in volgende functionaliteit: -

fungeert als stockeerruimte voor objecten

-

alloceert de ingebrachte objecten in de container

-

de-alloceert de uitgehaalde objecten uit de container

-

controleert de manier van stockeren, en biedt een specifieke interface om objecten op te halen uit de container.

Om deze functionaliteit te kunnen voorzien, bestaan containers gewoonlijk uit drie componenten: •

Elke container bevat functionaliteit om objecten op een welbepaalde manier op te slaan en op te zoeken. Met andere woorden, elke container heeft zijn eigen lidfuncties die uniek zijn voor die container en die het type van container bepalen. Zo zal een associatieve container toelaten om elementen op te zoeken met behulp van een sleutel, waarvoor specifieke lidfuncties voorzien zijn.

•

Elke container maakt gebruik van een ‘allocator’ om via dynamische geheugenallocatie de objecten te kunnen opslaan. Een allocator is een object dat via een welbepaalde interface hiervoor de nodige functionaliteit voorziet. Elke container heeft als één van zijn template-parameters zo’n allocator. De allocator template is default de template klasse allocator, met T de klasse waartoe de te stockeren objecten behoren. De klasse allocator maakt gebruik van de new en delete operator om dynamisch geheugen te alloceren voor objecten van het type T.

•

Elke container definieert ook de iterator die gebruikt moet worden voor het aanspreken van objecten in de container. De iterator van een container is specifiek voor die container, maar alle iteratoren hebben dezelfde interface. Op die manier is het gebruik van iteratoren voor verschillende types containers transparant voor de gebruiker.

2) Algoritmen Algoritmen zijn procedures die gewoonlijk in combinatie met containers gebruikt worden. Gewoonlijk zorgen algoritmen ervoor dat de structuur van de container wordt veranderd, bijvoorbeeld de volgorde in de container, of werken


195

in op een bepaald object van de container, bijvoorbeeld een transformatie van een object. 3) Iteratoren Iteratoren zijn objecten die als het ware de lijm vormen tussen containers en algoritmen. Een algoritme heeft niet rechtstreeks toegang tot de elementen van een container. Enkel via iteratoren kunnen algoritmen toegang hebben tot de elementen van een container. Iteratoren kunnen beschouwd worden als speciale C-pointers. Net zoals een pointer toegang biedt tot een bepaald geheugenelement, zo zal een iterator toegang bieden tot een element van een container. Binnen de STL-bibliotheek worden pointers trouwens beschouwd als iteratoren. 4) Functie-objecten Functie-objecten zijn speciale objecten, die eigenlijk ageren als gewone functies. Het zijn dus objecten die de rol vervullen van functies. Het voordeel van functie-objecten tenopzichte van gewone functies is het feit dat functie-objecten een toestand kunnen bewaren. Merk op dat de containers, de objecten geplaatst in deze containers, en de algoritmen die inwerken op de objecten van deze containers, onafhankelijk van mekaar bestaan.

7.5.2.2 Inleiding tot het gebruik van de STL-bibliotheek Volgend C-programma dient voor het vinden van een element in een array van integers. //programma P213.cpp #include <stdio.h> #include <stdlib.h> #define AANTAL 10 int *vinden(int *begin, int *einde, const int& element) { while (begin != einde && *begin !: element) ++begin; return begin; } int main(int argc, char* argv[]) { int reeks[AANTAL]; int i; int element; int *pgevonden; for (i= 0; i < AANTAL; i++) { reeks[i]= rand()%AANTAL; printf(“Waarde %d is %d\n”, reeks[i]); }

196

printf(“Typ een getal in: “); scanf(“%d”, &element); pgevonden= vinden(reeks, reeks+AANTAL, element); if (pgevonden == reeks+AANTAL) printf(“Het element is niet gevonden.\n”); else printf(“Het element is gevonden op plaatst %d.\n”, pgevondenreeks); return 0; } Het algoritme vinden() veronderstelt expliciet dat de container, waarin gezocht moet worden, hier de container reeks, elementen van het type int bevat. Om een element in een char array te vinden, moet in principe het algoritme vinden() worden herschreven. Echter met gebruik van templates moet dit algoritme niet worden herschreven. We schrijven een vinden()-template, die als variabel type het type heeft van het element in de array. De aangepaste versie van het algoritme vinden() is als volgt: template T *vinden(T *begin, T *einde, const T& element) { while (begin != einde && *begin != element) ++begin; return begin; } Met deze template-functie kan gezocht worden naar een element in gelijk welk type array. Echter kan de template-functie niet gebruikt worden voor andere types van containers, zoals een gelinkte lijst, omdat de template-functie expliciet veronderstelt dat de elementen sequentieel gestockeerd zijn, en via gewone pointers kunnen geadresseerd worden. Een meer algemene template-functie vinden() zou op de volgende manier kunnen geïmplementeerd worden: template < class Iterator, class T> Iterator vinden(Iterator begin, Iterator einde, const T& element) { while (begin != einde && *begin != element) ++begin; return begin; } De meer algemene template-functie vinden() maakt expliciet gebruik van het begrip iterator. De iterator vervangt het pointertype. Nu wordt geen veronderstelling meer gemaakt over de ordening van de elementen waarnaar de iterator verwijst. De iterator moet enkel toegang kunnen hebben tot de elementen in de container, en moet kunnen ‘springen’ naar een volgend element. Hiervoor moet de iterator kunnen gebruik maken van volgende operatoren: T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

197

•

de operator++, om te springen naar een volgend element in de container

•

de operator*, om een dereferentie te doen van het element waarnaar verwezen wordt. Met andere woorden, deze operator geeft de waarde terug van een element in de container.

•

De operator !=, om iteratoren met elkaar te vergelijken.

Daarbij moet de iterator kennis hebben van het type van container. Immers, de vereiste operatoren kunnen pas hun taak uitvoeren als ze kennis hebben van de interne structuur van de container. Het springen naar een volgend element zal afhangen van het feit of de container een vector of een list is. Iteratoren zijn daarom dan ook gewoonlijk gedefinieerd in de container zelf. Volgend codefragment maakt expliciet gebruik van de STL-bibliotheek. #include #include #include using namespace std; #define AANTAL 10 int main(int argc, char* argv[]) { vector reeks(AANTAL); vector :: iterator i; vector :: iterator gevonden; int element; for (i= reeks.begin(); i != reeks.end(); i++) { *i = rand()%AANTAL; cout << “Waarde “ << i – reeks.begin() << “ is “ << *i << endl; } cout << “Typ een getal in: “; cin >> element; gevonden= vinden(reeks.begin(), reeks.einde(), element); if (gevonden == reeks.end()) printf(“Het element is niet gevonden.\n”); else printf(“Het element is gevonden op plaatst %d.\n”, pgevondenreeks); return 0; } In bovenstaand codefragment is als container een vector gebruikt. De vector is een template-klasse en representeert een containertype dat elementen sequentieel stockeert, net zoals een array. De gestockeerde elementen zijn van het type int. De gebruikte iteratoren ‘i’ en ‘gevonden’ zijn van het type vector::iterator. Zo’n iterator heeft toegang tot de interne elementen van vector, zodat ze de nodige acties kunnen uitvoeren op die elementen.

198

De lidfuncties begin() en end() van vector bepalen het begin en einde van de vector. Beide lidfuncties geven een iterator terug naar respectievelijk het begin en het einde van de vector.

7.5.2.3 Lidfuncties van een container De belangrijkste gemeenschappelijke lidfuncties van een container zijn: •

iterator begin(): geeft een iterator terug naar het begin van de container.

•

iterator end(): geeft een iterator terug gepositioneerd voorbij het einde van de container.

•

size_type max_size(): geeft de maximale grootte terug van de container vooraleer de container nieuw geheugen moet alloceren voor het stockeren.

•

size_ type size(): geeft de huidige grootte, dit is het aantal elementen in de container, terug van de container.

•

bool empty(): duidt aan of de container al of niet leeg is.

•

void swap(X&): doet een swap van elementen. Hierbij worden alle elementen van de ene container overgedragen naar de andere container en omgekeerd.

De operatoren voor de container zijn: •

bool operator= (const X&)

•

bool operator== (const X&)

•

bool operator!= (const X&)

•

bool operator< (const X&)

•

bool operator>(const X&)

•

bool operator<= (const X&)

•

bool operator>= (const X&)

Alle containers groeien automatisch aan wanneer er te weinig geheugen voorradig is om alle elementen te stockeren. Er wordt niet geverifieerd of buiten de container wordt geschreven. Het is dus belangrijk dat altijd geverifieerd wordt of men geen elementen aanspreekt die niet in de container liggen.

7.5.2.4 De Vector container De Vector container is een sequentiële container. De Vector container implementeert een lineaire stockering van objecten in een aaneensluitende geheugenruimte. Vlug toevoegen van elementen kan enkel achteraan de vector. De elementen worden geadresseerd door hun index in de array. Het definiëren van een vector gebeurt als volgt: vector> IntVector; Vector IntVector definieert een vector van integers, waarbij als allocator de default allocator ‘allocator’ gebruikt wordt. Lidfuncties van de Vector container: •

X(n, t): construeert een sequentie van type X met n kopieën van t.

•

X(i, j): construeert een sequentie van type X met een kopie van elementen in de reeks van elementen tussen de iteratoren i en j.

•

iterator insert(p, t): kopieert element t voor locatie p.


199

•

void insert(p, n, t): element t wordt n keer gekopieerd voor locatie p.

•

void insert(p, i, j): kopieert de reeks van elementen in de reeks[i, j] voor locatie p.

•

iterator erase(q): verwijdert het element aanwezen door q.

•

iterator erase(q1, q2): verwijdert de elementen in het gebied[q1, q2].

•

reference front(): geeft een referentie terug naar het eerste element van de container.

•

reference back(): geeft een referentie terug naar het laatste element van de container.

•

void push_back(t): voegt het element t toe aan het einde van container.

•

void pop_back(t): verwijdert het element aan het einde van container en stopt het in t.

•

reference operator[](n): geeft een referentie terug naar het n-de element van de container.

•

reserve(n): reserveert geheugenruimte voor ten minste n elementen. Handig als men op voorhand weet hoeveel additionele elementen er nodig zijn.

•

size_type capacity(n): geeft het aantal te stockeren elementen weer zonder dat nieuwe geheugenruimte moet gereserveerd worden.

7.5.2.5 De List container De List container implementeert een dubbel gelinkte lijst. Dit impliceert de volgende eigenschappen voor de container: •

De elementen in de container zijn geordend en hebben dus een welbepaalde volgorde.

•

Het toevoegen of verwijderen van elementen gebeurt vlug en dit op gelijk welke plaats in de container.

•

De list gebruikt meer geheugen per element dan een vector, maar is efficienter in het geheugengebruik als de grootte van de container sterk varieert tijdens de duur van het programma.

•

Elementen in de lijst kunnen niet worden geïndexeerd.

•

Het zoeken van elementen gebeurt door het doorlopen van de volledige lijst.

De meest gebruikte lidfuncties voor een list container zijn: •

void merge(list &): voegt twee lijsten samen tot één lijst.

•

void push_front(const T& t): voegt een element toe aan het begin van de lijst.

•

void pop_front(): verwijdert het element aan het begin van de lijst.

•

void remove(const T& t): verwijdert alle elementen die gelijk zijn aan het element t.

•

void remove_if(Predicate P): verwijdert die elementen waarvoor het predikaat geldig is.

•

void reverse(): inverteert de orde in de lijst.

•

void sort(): sorteert de elementen in de lijst. Het sorteercriterium is de < operator, gedefinieerd voor de elementen.

•

void unique(): verwijdert alle identieke opeenvolgende elementen, behalve het eerste element.

200

7.6 Klassen voor algemeen gebruik 7.6.1 De CTime-klasse De klasse CTime representeert datum- en tijdinformatie. De functies van de klasse CTime zijn: •

CTime: constructor

•

GetCurrentTime: creëert een object CTime, dat de huidige tijd representeert.

•

GetYear: geeft het jaar van de systeemdatum terug.

•

GetMonth: geeft de maand van de systeemdatum terug.

•

GetDay: geeft de dag van de systeemdatum terug.

•

GeHour: geeft het uur van de huidige systeemtijd terug.

•

GetMinute: geeft de minuut van de huidige systeemtijd terug.

•

GetSecond: geeft de seconde van de huidge systeemtijd terug.

•

GetDayOfWeek: geeft de dag van de week terug.

•

Format: geeft een geformatteerde tijdstring terug

De klasse CTime heeft volgende operatoren: •

operator= : assigneert (toekennen) een nieuwe tijd.

•

operator+ : telt twee objecten CTime op en geeft een object CTime terug. Met andere woorden, operator+ telt twee tijden op en geeft hun som terug.

•

operator- : geeft het verschil tussen twee datums terug in een object CTimeSpan.

7.6.2 De CString-klasse De klasse CString zorgt voor de manipulatie van strings. De klasse CString bewaart strings gerepresenteerd door een variabele array van ‘char’ variabelen. De string kan een lengte hebben van maximaal 32766 karakters. De belangrijkste lidfuncties van de klasse CString zijn: •

CString: constructor

•

~CString: destructor

•

GetLength: geeft de lengte van de string terug

•

MakeUpper: converteert de string naar uppercase (hoofdletters)

•

MakeLower: converteert de string naar lowercase (gewone letters)

•

Find: zoekt een karakter of substring in een object CString

•

FindOneOf: zoekt het eerste karakter in de string dat overeenstemt met het opgegeven karakter

De klasse CString heeft volgende operatoren: •

operator[]: geeft het karakter op de opgegeven positie terug

•

operator= : assigneert een gegeven string aan een nieuwe string

•

operator+ : concateneert (samenvoegen) twee strings en geeft de nieuwe string terug.


201

7.6.3 Voorbeeld Het volgende programma maakt gebruik van de klassen CTime en CString. Het programma •

vraagt naar twee datums vanaf 1/1/2000, waarbij de tweede datum groter moet zijn dan de eerste datum,

•

controleert de ingevoerde datums,

•

berekent het aantal dagen tussen die twee datums,

•

en berekent het totaal aantal uren, het totaal aantal minuten en het totaal aantal seconden tussen die twee datums.

//programma P214.cpp #include #include void main() { char cArray[80]; bool fout= FALSE; unsigned int jaar1, maand1, dag1; unsigned int jaar2, maand2, dag2; CTime datum1, datum2;

do { do { CString datum; fout= FALSE; cout<<”Typ eerste datum in (yy/mm/dd): “; cin>>cArray; datum= cArray; jaar1= atoi(datum.Left(2)); maand1= atoi(datum.Mid(3, 2)); dag1= atoi(datum.Right(2)); if (dag1 == 0 || maand1 == 0 || jaar1 == 0) fout= TRUE; cout<<”Typ tweede datum in (yy/mm/dd), groter dan eerste datum: “; cin>>cArray; datum= cArray; jaar2= atoi(datum.Left(2)); maand2= atoi(datum.Mid(3, 2)); dag2= atoi(datum.Right(2)); if (dag2 == 0 || maand2 == 0 || jaar2 == 0) fout= TRUE; }

202

while ((fout == TRUE) && (cout<<”foutieve datum(s) ingevoerd” << endl)); datum1= CTime(2000+jaar1, maand1, dag1, 1, 1, 1); datum2= CTime(2000+jaar2, maand2, dag2, 1, 1, 1); } while ((datum1 >= datum2) && (cout<<”datum1 groter dan datum2”<<endl; CTimeSpan Tverschil= datum2 – datum1; cout<<”Het verschil tussen “<
8. Object georiënteerd ontwerp 8.1 Systeem van onderling handelende objecten Een C-programma is opgebouwd uit functies die sequentieel uitgevoerd worden. Een C-programma beschrijft een serie van stappen, die uitgevoerd moeten worden. Een C-programmeur moet dus machine-gebonden denken. Immers, een computer verwerkt gegevens via een sequentie van bewerkingen. In tegenstelling daarmee maakt een OO-taal het de programmeur mogelijk om minder machine-gebonden te moeten denken. In plaats van code te schrijven die bestaat uit een sequentie van uit te voeren stappen, kan een C++ prgrammeur zich concentreren op het bouwen van objecten waaruit het probleem bestaat. Een C++ programma beschrijft zodoende een systeem van onderling handelende objecten. Voorbeeld: Als we bepaalde complexe zaken willen behandelen, dan beroepen we ons op onze mogelijkheid om abstracties te maken van het gegeven. Met andere woorden, we trachten het gegeven te herleiden tot zijn eenvoudigste vorm, en we zoeken analogieën met reeds gekende zaken. Als we het begrip ‘auto’ moeten omschrijven, dan zullen we in eerste instantie niet praten over de ontsteking, maar wel over het feit dat een auto dient om zich te verplaatsen, dat een auto vier wielen en een motor heeft, enz…. Als iemand over een ‘auto’ spreekt, dan identificeren we het begrip ‘auto’ met een abstracte klasse ‘automobiel’, zonder dat we refereren naar bijvoorbeeld de specifieke kleur, of het aantal pk. Op die manier zijn we in staat het algemeen van het detail te scheiden.


203

Bovendien moeten we geen autotechnicus zijn om te beseffen hoe een auto werkt, omdat we abstractie kunnen maken van bepaalde functies van een auto. Zo moeten we bijvoorbeeld niet weten hoe een motor in mekaar steekt om te kunnen beseffen dat de motor de wielen aandrijft en zodoende de auto laat voortbewegen. OOP laat toe om eenzelfde denkwijze te volgen voor de programmatie. Wanneer we bijvoorbeeld het object ‘auto’ willen implementeren in een programma, dan volstaat het een algemene klasse ‘automobiel’ te bouwen. Hoe de klasse ‘automobiel’ er inwendig uitziet is voor de uiteindelijke gebruiker van het object auto niet van belang. OOP laat immers toe de inwendige constructie van een object te verbergen voor de gebruiker en enkel die functionaliteit zichtbaar te maken die noodzakelijk is voor het gebruik van dat object.

8.2 Object georiënteerd ontwerp versus procedureel ontwerp Een object georiënteerd ontwerp verschilt fundamenteel van een procedureel georiënteerd ontwerp. •

Een procedureel georiënteerd ontwerp legt de nadruk op de nodige procedures, op wat voor functies het programma moet vervullen. Bij de analyse van een probleem, vraagt een C-programmeur zich af: “Wat moet het programma uitvoeren? Welke functies moet het bevatten?”. Het probleem wordt gezien als een veelvoud van uit te voeren functies.

•

Een object georiënteerd ontwerp legt de nadruk op wat voor objecten het programma moet manipuleren. De focus wordt meer gelegd op de data die het programma moet manipuleren en minder op de functionaliteit van het programma. Het probleem wordt gezien als een verzameling van objecten. Met andere woorden, de C++ programmeur maakt een model op van het probleem aan de hand van objecten waaruit het programma bestaat.

Voorbeeld: De opbouw van een grafisch tekenprogramma is in een procedurele aanpak toegespitst op functies voor het weergeven van figuren op het scherm en voor het verplaatsen en uitwissen van die figuren. Die functies vormen de basiscomponenten van het programma. In een OO-aanpak ligt de focus op de objecten die moeten worden gemanipuleerd, zoals veelhoeken, rechthoeken, cirkels, enz…. Deze objecten vormen de basiscomponenten van het programma.

8.3 Stappen in een object georiënteerde aanpak Een object georiënteerde aanpak bevat volgende stappen: 1) Het identificeren van de nodige klassen. 2) Het bepalen van de hiërarchie van de klassen. 3) Het definiëren van de interface van elke klasse. 4) Het programmeren van de klassen. 5) Het schrijven van het hoofdprogramma.

204

8.3.1 Identificatie van de klassen Het identificeren van de benodigde klassen kan gebeuren door de taak van het programma neer te schrijven en alle zelfstandige naamwoorden in deze taakbeschrijving als mogelijke klassen te beschouwen. Voorbeeld: Een ‘grafisch tekenpakket’ laat toe om ‘grafische objecten’ te tekenen op het ‘scherm’. Deze ‘grafische objecten’ zijn een ‘verzameling’ van ‘rechthoeken’, ‘cirkels’ en ‘ellipsen’. Uit de taakbeschrijving volgen de mogelijke klassen: •

grafisch tekenpakket: object dat het programma voorstelt

•

grafisch object: de basisklasse voor de verschillende figuren

•

scherm: dit kan een venster zijn binnen het scherm, of een object dat verschillende resoluties kan behandelen

•

verzameling: een collectie (bijvoorbeeld een gelinkte lijst) van figuren

•

rechthoek, cirkel, ellips: afgeleide klassen van de klasse ‘grafisch object’

8.3.2 Hiërarchie van de klassen •

Het bepalen van de hiërarchie van de klassen betekent het bepalen van de erfelijkheidsrelaties tussen de verschillende klassen. Hierbij moet rekening gehouden worden met de ‘is een’-relatie tussen de verschillende klassen. Voorbeeld: De klassen rechthoek, cirkel, ellips zijn afgeleide klassen van de klasse ‘grafisch object’. Immers, een rechthoek ‘is een’ grafisch object. Ook een cirkel ‘is een’ grafische object.

•

Bij een ‘heeft een’-relatie tussen twee klassen zal een object behorend tot de ene klasse ook lid zijn van de andere klasse. Voorbeeld: Een grafisch tekenpakket ‘heeft een’ verzameling van grafische objecten. Met andere woorden, de klasse ‘grafisch tekenpakket’ zal een object ‘verzameling’ als data-lid hebben.

8.3.3 Interface van de klassen De volgende stap in een OO-ontwerp is de definitie van de interface van elke klasse. De interface bepaalt de relatie van de klasse met zijn omgeving. Dit betekent concreet het definiëren van de verschillende lidfuncties (de methodes) en de lidvariabelen (de data-leden of attributen) van elke klasse. Bij de definitie van de interface moet rekening gehouden worden met: 1) Als een lidfunctie of data-lid algemeen is voor alle klassen in de klassenhiërarchie, dan moeten die gedefinieerd worden in de basisklasse, anders in die klasse waarvoor ze specifiek zijn.


205

Voorbeeld: De functie tekenen() moet in de basisklasse ‘grafisch object’ worden gedefinieerd, omdat tekenen() geldig is voor alle afgeleide klassen, zoals rechthoek, cirkel, enz…. Het data-lid ‘straal’ wordt enkel in de klasse ‘cirkel’ gedefinieerd omdat ‘straal’ specifiek is voor een cirkel. 2) Als de implementatie van een lidfunctie, die geldig is voor alle klassen binnen een klassenhiërarchie, algemeen is voor al die klassen, dan is die lidfunctie een gewone lidfunctie van de basisklasse. Die lidfunctie wordt dan door de afgeleide klassen overgeërfd. Echter, als die lidfunctie een eigen specifieke implementatie voor elke klasse vereist, dan moet die lidfunctie als ‘virtual’ worden gedefinieerd en geldt het principe van polymorfisme. Voorbeeld: De lidfunctie tekenen() wordt als ‘virtual’ gedefinieerd in de basisklasse en zal een eigen implementatie krijgen in de afgeleide klassen rechthoek, cirkel, …. 3) Als een lidfunctie en/of data-lid moet beschikbaar zijn voor het volledige programma, dan moeten ze deel uitmaken van de publieke interface. In het geval ze enkel moeten beschikbaar zijn in de klassenhiërarchie, moeten ze deel uitmaken van de private interface.

8.3.4 Programmatie van de klassen Na de definitie van de interface wordt de klasse volledig geprogrammeerd en uitgetest. Het uittesten van objecten is eenvoudiger dan het uittesten van individuele functies bij een procedureel ontwerp. Immers, de objecten bevatten de data en de procedures die op deze data inwerken. Voor het uittesten van een object zijn er geen andere externe variabelen nodig zoals die wel nodig zijn voor het uittesten van individuele functies. Objecten zijn entiteiten die op zichzelf kunnen bestaan, los van een programma. Objecten kunnen dan ook los van het programma worden uitgetest.

8.3.5 Schrijven van het hoofdprogramma Pas nadat alle klassen zijn gebouwd en uitgetest, wordt het hoofdprogramma geschreven en uitgetest.

8.4 Constructie van correcte klassen Hier volgen enkele tips om een klasse correct te construeren: 1) Een klasse moet een concept voorstellen dat gemakkelijk kan uitgelegd worden aan iemand die geen programmeur is. Een klasse is gewoonlijk een voorstelling van een concreet object dat in het programma moet worden gemanipuleerd.

206

In een grafisch programma is bijvoorbeeld een object een rechthoek. In een vliegsimulator is een object een vliegtuig en in een bedrijf is een object een werknemer. Normaal moet een klasse in enkele lijnen tekst kunnen worden beschreven. Een klasse moet een actief object voorstellen. Dit betekent dat een object iets moet ‘doen’ en niet enkel iets ‘is’. Als een klasse enkel iets ‘is’, kan die klasse herleid worden naar een structuur. 2) Een klasse mag niet te groot worden. In dat geval moet een ‘ouder-klasse’ een deel van de karakteristieken van de klasse overnemen. 3) Een klasse moet elk mogelijk object, dat van deze klasse kan worden geïnstantieerd, volledig kunnen omschrijven. 4) Verwar het begrip ‘klasse’ niet met het begrip ‘object’. Een object is een specifieke instantie van een klasse, het is iets concreet aanwijsbaar. Voorbeeld: Een boot, genaamd ‘Stormvogel’ is een object van de klasse Boot. Echter kan een ‘zeilboot’ geen object zijn van de klasse Boot, omdat Boot geen karakteristieken bevat die specifiek weergeven dat een zeilboot voortgestuwd wordt door de wind. Wel kan ‘Zeilboot’ een afgeleide klasse zijn van Boot, omdat het een specialisatie betreft van het concept boot. 5) In de hiërarchie van klassen moet uiteraard de basisklasse de meest algemene en meest eenvoudige klasse zijn. Afgeleide klassen zijn een specialisatie van de klasse waarvan ze zijn afgeleid. Vergeet daarbij niet dat iedere afstammeling alle eigenschappen van zijn voorouders overerft. Met andere woorden, een afstammeling bevat het geheel van functionaliteiten en karakteristieken van zijn voorouders. 6) Zorg ervoor dat een afgeleide klasse een ‘is een’-relatie of een ‘gelijkend op’relatie onderhoudt met zijn ouderklasse. 7) Gebruik maximaal encapsulatie. Dit betekent zoveel mogelijk leden van een klasse als privaat declareren. Het hergebruiken van reeds bestaande klassen kan maar succesvol gebeuren als de klassen een bestaan op zichzelf hebben, los van de rest van de programmatuur. 8) Maak gebruik van voorgedefinieerde klassen, zoals sequentiële lijsten, gelinkte lijsten, stapels, enz…

8.5 Voordelen van het aanwenden van OOP Het aanwenden van OOP biedt een aantal voordelen voor de software-ontwikkelaar: 1) Hergebruikbaarheid In OOP worden objecten (klassen) gecreëerd die als zelfstandige entiteiten door het leven gaan. Ieder object staat los van een ander object en heeft geen connecties met andere code. De objecten kunnen als het ware rechtstreeks in de code geplugd worden, net zoals bjvoorbeeld IC’s op een printplaat worden geplaatst. Op die manier is het mogelijk om, eens een object volledig is uitgewerkt en getest, die opnieuw te gebruiken als een standaard softwarecomponent. T:\Modules\SYLLABUS\Programmeur X51\Programmeren in C++\020819 Programmeren in C++.doc

207

2) Onderhoudbaarheid OOP-code is leesbaarder en daardoor ook beter te onderhouden dan een procedurele aanpak, omdat OOP-code dichter aansluit bij het menselijk denken dan de tradionele procedurele methoden. Bovendien zijn de data en de procedures die op deze date inwerken, gegroepeerd in de objecten, en geïsoleerd van de rest. Een wijziging van een object (klasse) zal dus enkel de data en de code beïnvloeden binnen dat object, terwijl andere objecten (klassen) geen last ondervinden van de wijziging. Dit bevordert in grote mate de onderhoudbaarheid van de code. Daarenboven veranderen de objecten van een programma gewoonlijk niet in de tijd. Alleen worden attributen en/of methoden toegevoegd of weggelaten, of worden er objecten (klassen) toegevoegd. Dit heeft als gevolg dat de oorspronkelijke object georiënteerde analyse van het programma, mits kleine aanpassingen, behouden kan worden. 3) Betrouwbaarheid OOP laat toe om objecten (klassen) afzonderlijk uit te testen, los van het programma waarin het object geïmplementeerd wordt. Dit laat toe om de verschillende programma-onderdelen los van elkaar te ontwikkelen en uit te testen. Doordat de koppeling tussen objecten in het uiteindelijk programma gewoonlijk zeer zwak is, kan men erop vertrouwen dat het uiteindelijk programma even betrouwbaar is als de objecten waaruit het is opgebouwd.

8.6 Een op data gerichte aanpak Een programmeertaal die een data gerichte aanpak van een probleem ondersteunt, moet volgende hulpmiddelen aanbieden: -

data abstractie en objecten

-

encapsulatie

-

inheritance

-

polymorfisme en dynamische binding

8.6.1 Data abstractie Data wordt gemodelleerd door middel van data abstractie. De abstracte datatypen, die via data abstractie ontstaan, zijn de klassen voor de verdere ontwikkeling van het programma. In heel wat gevallen moet data worden gegroepeerd. Zo wordt van een aantal personen de naam, adres, woonplaats en geboortedatum niet los van mekaar bijgehouden, maar worden die gegevens gegroepeerd per persoon, bijvoorbeeld het datatype ‘persoon’, dat de data-elementen naam, adres, woonplaats en geboortedatum bevat. Dergelijke datatypen heten abstracte datatypen, die zeer geschikt zijn voor data abstractie. Een object is een instantie van een data-structuur die data combineert met functies die op deze data inwerken. Objecten worden gebruikt als zelfstandige entiteiten, die zowel een bepaalde toestand hebben door middel van de waarden van hun dataelementen, als een bepaalde functionaliteit vervullen door middel van de procedures die ze bevatten. De concrete inwendige implementatie van het object

208

speelt hier geen rol. Alleen het gebruik van het object is gedefinieerd door middel van zijn klassebeschrijving. De klasse is niets anders dan de beschrijving van de structuur van een object. Een object bestaat uit data-elementen (attributen) en routines (methodes). De attributen van een object drukken een ‘heeft een’-relatie uit. Zo is ‘vleugels’ een attribuut van het object Vogel. Immers, een vogel ‘heeft’ vleugels. De methodes behorend tot het object, drukken een ‘kan’-relatie uit. Zo is ‘vliegen’ een methode van het object Vogel. Immers, een vogel ‘kan’ vliegen.

8.6.2 Encapsulatie Encapsulatie, ook data hiding genoemd, is het afschermen van data en functies. Dit betekent dat die data en lidfuncties enkel zichtbaar zijn binnen de klasse waartoe ze behoren. Het gevolg van data hiding is dat een ontwerp bestaat uit losse elementen, die onderling niet veel binding met mekaar hebben. Dit betekent dat het gebruik van die elementen minder gebonden is aan een bepaalde volgorde en dat het onderhoud van een programma eenvoudiger wordt doordat interface functies (lidfuncties) nu gekoppeld zijn aan een bepaald datatype en dus vlug kunnen gelokaliseerd worden. Via encapsulatie ontstaat een duidelijk omschreven systeem dat een verborgen implementatie (private) bevat, en een aantal functies die dienen als interface (public) voor het systeem.

8.6.3 Inheritance Inheritance of overerving is de techniek voor het uitbreiden of specialiseren van een abstract datatype. Bij overerving wordt een nieuw datatype (afgeleide klasse) gedefinieerd in termen van een ander datatype (basisklasse). Zo is bijvoorbeeld een spaarrekening (nieuw datatype) een specialisatie van het bestaande datatype rekening. De spaarrekening heeft wel als eigen kenmerken (specialisatie) bijvoorbeeld een minimale inleg of een rente die afhangt van de spaarhoeveelheid, doch ze bevat ook nog steeds alle eigenschappen van het datatype rekening. Via de techniek van overerving moet voor een nieuw soort rekening, bijvoorbeeld een zichtrekening, de bestaande code niet worden opengebroken. Het volstaat eenvoudig van het datatype ‘rekening’ het nieuwe datatype ‘zichtrekening’ af te leiden. Immers, een zichtrekening ‘is een’ rekening. Inheritance maakt het mogelijk om bestaande abstracte datatypes uit te breiden of te specialiseren zonder het origineel te moeten wijzigen. Een nieuw datatype, afgeleid van een bestaand datatype, erft de eigenschappen van het bestaande datatype zonder dit te wijzigen of te kopiëren. Uiteraard betekent dit dat de databeschrijving (data-leden) en de functies (lidfuncties) die een abstract datatype moeten manipuleren, alle op één en dezelfde plaats moeten worden verzameld. Dit heeft als gevolg dat ‘als’ er wat moet veranderen aan de specificatie van een datatype, die aanpassing enkel op ‘die’ plaatsen moet gebeuren.


209

8.6.4 Polymorfisme en dynamische binding Inheritance doet een hiërarchie ontstaan van objecten, die uitgaan van hetzelfde basistype (oudertype). Vanuit dit feit is het wenselijk om verschillende vormen automatisch te kunnen herkennen zonder daarvoor informatie te moeten bijhouden. Polymorfisme is de mogelijkheid om objecten te creëren die tijdens runtime van vorm kunnen veranderen. Dynamische binding is de faciliteit die ervoor zorgt dat automatisch de juiste interface-functies worden gebruikt.

8.6.5 Besluit Overerving en polymorfisme zijn de hoofdzaken van een OO-taal. Ze steunen echter volledig op data abstractie en encapsulatie. Een op data gerichte aanpak biedt het voordeel dat uitbreidingen vlugger en meer onafhankelijk kunnen gerealiseerd worden en dat een nieuw project kan gebruik maken van delen uit reeds ontwikkelde projecten. Programmeertalen die data abstractie, encapsulatie, inheretance en polymorfisme mogelijk maken en het gebruik van deze mogelijkheden kunnen afdwingen, worden object georiënteerd talen genoemd. C++ is een taal die de eisen voor een object georiënteerde programmeerwijze ondersteunt, doch de procedurele manier van programmeren niet onmogelijk maakt (hybride taal).

210


211

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

Recommend Documents