Softwareentwicklung in C++ - ASC

Weitere Magazine

Empfehlungen

Info

230 9. Klassen in C++ BaseB : : dynamicallyBoundMethod c a l l e d constructor of DerivedB DerivedB : : dynamicallyBoundMethod c a l l e d constructor of DerivedC DerivedC : : dynamicallyBoundMethod c a l l e d −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− ∗∗∗∗∗ new t e s t o b j p t r ∗∗∗∗∗ constructor of BaseA BaseA : : dynamicallyBoundMethod c a l l e d constructor of DerivedA DerivedA : : dynamicallyBoundMethod c a l l e d constructor of BaseB BaseB : : dynamicallyBoundMethod c a l l e d constructor of DerivedB DerivedB : : dynamicallyBoundMethod c a l l e d constructor of DerivedC DerivedC : : dynamicallyBoundMethod c a l l e d −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− ∗∗∗∗∗ c a l l i n g method on t e s t o b j p t r ∗∗∗∗∗ DerivedC : : dynamicallyBoundMethod c a l l e d −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− ∗∗∗∗∗ d e l e t e t e s t o b j p t r ∗∗∗∗∗ d e s t r u c t o r of DerivedC DerivedC : : dynamicallyBoundMethod c a l l e d d e s t r u c t o r of DerivedB DerivedB : : dynamicallyBoundMethod c a l l e d d e s t r u c t o r of BaseB BaseB : : dynamicallyBoundMethod c a l l e d d e s t r u c t o r of DerivedA DerivedA : : dynamicallyBoundMethod c a l l e d d e s t r u c t o r of BaseA BaseA : : dynamicallyBoundMethod c a l l e d −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− ∗∗∗∗∗ now t e s t o b j e c t ’ s l i f e t i m e ends ∗∗∗∗∗ d e s t r u c t o r of DerivedC DerivedC : : dynamicallyBoundMethod c a l l e d d e s t r u c t o r of DerivedB DerivedB : : dynamicallyBoundMethod c a l l e d d e s t r u c t o r of BaseB BaseB : : dynamicallyBoundMethod c a l l e d d e s t r u c t o r of DerivedA DerivedA : : dynamicallyBoundMethod c a l l e d d e s t r u c t o r of BaseA BaseA : : dynamicallyBoundMethod c a l l e d Die erste Auffälligkeit in unserem Testprogrämmchen zeigt sich in Zeile 21: Der Destruktor von BaseA ist virtual! Ebenso sind alle Destruktoren aller anderen Klassen als virtual deklariert. Dies hat noch nichts mit dem Bauen der virtual Table an sich zu tun, sondern hat einen ganz anderen aber sehr wichtigen Grund. Dazu werfen wir einmal einen Blick auf die Zeilen 200– 206. In diesen Zeilen wird ein Objekt vom Typ DerivedC dynamisch erzeugt, allerdings wird dieser Pointer in einer Variable vom Typ BaseA * gehalten. Dies ist, wie bereits bekannt ist, absolut zulässig und gängige Praxis, z.B. bei Parameterübergaben, wie wir sie schon kennen gelernt haben. In Zeile 204 sieht man wieder, was sowieso schon bekannt ist: Beim Call einer virtual Methode wird zur Laufzeit entschieden, welche der Implementationen in der Ableitungshierarchie nun tatsächlich aufgerufen wird. Zeile 206 allerdings ist nun des Pudels Kern, was die ominösen virtuellen Destruktoren anbelangt: Stellen wir uns einfach vor, die Destruktoren
9.4 Weitere wichtige technische Aspekte 231 wären statisch und nicht dynamisch gebunden. Dadurch würde Furchtbares passieren, nämlich dass ausschließlich der Destruktor von BaseA aufgerufen wird. Der Compiler hat ja statisch diesen Aufruf eingefügt. Was allerdings passieren muss, damit das Programm korrekt funktioniert, ist, dass alle Destruktoren der einzelnen Klassen in der Ableitungshierarchie korrekt aufgerufen werden. Genau das erreicht man nur, wenn man mit dynamic Binding arbeitet, also den Destruktor virtual deklariert. Damit wird zur Laufzeit entschieden, welcher der “tiefste” Destruktor des vorliegenden Objekts ist und von diesem ausgehend werden die anderen Destruktoren, die höher in der Ableitungshierarchie liegen, korrekt aufgerufen. Vorsicht Falle: Die schweißtreibendsten Debug Sessions, an denen schon sehr viele Entwickler verzweifelt sind, ergeben sich bei der Suche nach völlig unerklärlichen Effekten, die durch einen statisch gebundenen Destruktor trotz dynamischer Verwendung von Objekten zustande kommen. Aus diesem Grund lautet die Grundregel Nummer eins beim Entwickeln von C ++ Programmen: Jede Klasse muss unbedingt einen virtual Destruktor besitzen! Auch wenn dies in manchen Fällen aufgrund der Verwendung als nicht notwendig erscheint, so ist man auf jeden Fall bei Einhalten dieser Regel immer auf der sicheren Seite. Vor allem passiert es oft genug, dass nach Programmänderungen Objekte polymorph verwendet werden, obwohl das zuvor beim Grunddesign der Klasse noch gar nicht der Fall und leider auch nicht mitgeplant war. Und genau dann kommt es garantiert zur Katastrophe. Zum Glück warnen moderne Compiler, wenn man in einer Klasse virtual Methoden hat, aber den Destruktor nicht virtual deklariert. Nun zum eigentlichen Thema unseres Testprogramms: Es galt, herauszufinden, wie die virtual Table aufgebaut (und auch wieder abgebaut) wird. Um festzustellen, welche Implementation der dynamisch gebundenen Methode gerade die “letzte aktive” in der virtual Table ist, wurden in die einzelnen Konstruktoren und in die einzelnen Destruktoren Outputs eingebaut. Betrachtet man den Output, der beim Erzeugen von test_object entsteht, so kann man Folgendes beobachten: • Im Konstruktor von BaseA wird dynamicallyBoundMethod aufgerufen. Der tatsächlich ausgeführte Call ist die Implementation, die durch BaseA gegeben ist. • Im Konstruktor der davon abgeleiteten Klasse DerivedA erfolgt, wie man sieht, ein Aufruf der Implementation, die durch DerivedA vorgegeben ist. • Selbiges passiert in allen anderen Konstruktoren, die der Reihe nach bis zum fertigen Objekt aufgerufen werden. Was sagt uns das in Bezug auf die virtual Table? Nun, ganz einfach: Die virtual Table wird sukzessive gemeinsam mit dem Aufruf der Konstruktoren
Seite 1:
Klaus Schmaranz Softwareentwicklung
Seite 4 und 5:
VI Vorwort des Autors Es ist das vo
Seite 6 und 7:
VIII Vorwort des Autors Last, but n
Seite 8 und 9:
X Inhaltsverzeichnis 4. Kontrollstr
Seite 10 und 11:
XII Inhaltsverzeichnis 11. Exceptio
Seite 13 und 14:
1. Ziel und Inhalt dieses Buchs Die
Seite 15 und 16:
1.1 Zum Inhalt 3 z.B. bei Abhandlun
Seite 17 und 18:
1.1 Zum Inhalt 5 stiegspunkte hat,
Seite 19 und 20:
1.2 Motivation 7 über die Hälfte
Seite 21:
1.4 Die beiliegende CD-ROM 9 Ich w
Seite 25 und 26:
2. Datentypen und Variablen Die Ver
Seite 27 und 28:
2.1 Primitive Datentypen 15 Wenn ma
Seite 29 und 30:
2.1 Primitive Datentypen 17 hat man
Seite 31 und 32:
2.1 Primitive Datentypen 19 Leser,
Seite 33 und 34:
2.2 Deklaration, Definition und Ini
Seite 35 und 36:
2.2 Deklaration, Definition und Ini
Seite 37 und 38:
2.3 Das erste C++ Programm 25 Prinz
Seite 39 und 40:
a g l o b a l v a r : 1 7 a n o t h
Seite 41 und 42:
2.3 Das erste C++ Programm 29 • Z
Seite 43 und 44:
2.4 Zusammengesetzte Datentypen 2.4
Seite 45 und 46:
26 cout
Seite 47 und 48:
2.4 Zusammengesetzte Datentypen 35
Seite 49 und 50:
Seite 51 und 52:
Seite 53 und 54:
Seite 55 und 56:
Seite 57 und 58:
25 // of the anonymous union 26 num
Seite 59 und 60:
2.6 Symbolische Konstanten 47 Ich m
Seite 61 und 62:
2.7 Eigene Typdefinitionen 49 1. Ko
Seite 63:
2.7 Eigene Typdefinitionen 51 Um ü
Seite 66 und 67:
54 3. Operatoren kann auch durch Op
Seite 68 und 69:
56 3. Operatoren Rang Bedeutung Ope
Seite 70 und 71:
58 3. Operatoren Bis auf den “mod
Seite 72 und 73:
60 3. Operatoren Definition, dass 0
Seite 74 und 75:
62 3. Operatoren die Umwandlung in
Seite 76 und 77:
64 3. Operatoren 46 typeid ( long l
Seite 78 und 79:
66 3. Operatoren Was sieht man an u
Seite 80 und 81:
68 3. Operatoren Zahl als int und a
Seite 82 und 83:
70 3. Operatoren primitive Datentyp
Seite 84 und 85:
72 3. Operatoren Wieso eigentlich k
Seite 86 und 87:
74 4. Kontrollstrukturen 4.1 Select
Seite 88 und 89:
76 4. Kontrollstrukturen Ich habe h
Seite 90 und 91:
78 4. Kontrollstrukturen 8 using st
Seite 92 und 93:
80 4. Kontrollstrukturen Im Gegensa
Seite 94 und 95:
82 4. Kontrollstrukturen 23 cout
Seite 97 und 98:
5. Funktionen Prinzipiell ist eine
Seite 99 und 100:
5 6 using std : : cout ; 7 using st
Seite 101 und 102:
5. Funktionen 89 vom Overloading in
Seite 103 und 104:
5. Funktionen 91 korrekten Paramete
Seite 105 und 106:
5. Funktionen 93 paar für den Expo
Seite 107 und 108:
27 void show (double num) 28 { 29 c
Seite 109 und 110:
1 // i n l i n e f u n c t i o n d
Seite 111 und 112:
5. Funktionen 99 Einsatz. Dieser Um
Seite 113 und 114:
5. Funktionen 101 feilscht (=linear
Seite 115 und 116:
6. Pointer und References C ist sch
Seite 117 und 118:
46 void changeVariable ( int32 &var
Seite 119 und 120:
10 { 11 int32 my var = returnDeadVa
Seite 121 und 122:
6.1 References 109 werden müsste,
Seite 123 und 124:
42 a s t r u c t . a member = 17; 4
Seite 125 und 126:
6.1 References 113 alltägliche Pra
Seite 127 und 128:
6.2 Pointer 115 weitem stärker den
Seite 129 und 130:
41 ” , ∗ my ptr : ”
Seite 131 und 132:
6.2 Pointer 119 Wenn man aus guter
Seite 133 und 134:
6.2 Pointer 121 bei unseren kleinen
Seite 135 und 136:
6.2 Pointer 123 Zeilen 34-35: Hier
Seite 137 und 138:
6.2 Pointer 125 Zeilen 51-56: Die F
Seite 139 und 140:
25 for ( uint32 count = 0 ; count <
Seite 141 und 142:
16 const uint32 NUM COLS = 7; 17 6.
Seite 143 und 144:
6.2 Pointer 131 einen konstanten Po
Seite 145 und 146:
6.2 Pointer 133 Auf einer Sun würd
Seite 147 und 148:
7. Der Preprocessor In C ++ kommt d
Seite 149 und 150:
7.2 Bedingte Übersetzung 137 im ak
Seite 151:
7.3 Macros 139 dann kann man nette
Seite 155 und 156:
8. Objektorientierung Allgemein Ich
Seite 157 und 158:
8. Objektorientierung Allgemein 145
Seite 159 und 160:
8.1 Module und Abläufe 147 2. Die
Seite 161 und 162:
8.1 Module und Abläufe 149 Schritt
Seite 163 und 164:
8.1 Module und Abläufe 151 4. Man
Seite 165 und 166:
8.1 Module und Abläufe 153 Begriff
Seite 167 und 168:
8.2 Klassen und Objekte 155 • Im
Seite 169 und 170:
8.2 Klassen und Objekte 157 solche
Seite 171 und 172:
8.2 Klassen und Objekte 159 • Man
Seite 173 und 174:
8.3 Richtige Verwendung der OO Mech
Seite 175 und 176:
Seite 177:
Seite 180 und 181:
168 9. Klassen in C++ 9.1 Besonderh
Seite 182 und 183:
170 9. Klassen in C++ se Art der De
Seite 184 und 185:
172 9. Klassen in C++ ses Beispiel
Seite 186 und 187:
174 9. Klassen in C++ private: Es d
Seite 188 und 189:
176 9. Klassen in C++ 1 // memory g
Seite 190 und 191:
178 9. Klassen in C++ hinter sich h
Seite 192 und 193: 180 9. Klassen in C++ Compiler wiss
Seite 194 und 195: 182 9. Klassen in C++ Objekt, das z
Seite 196 und 197: 184 9. Klassen in C++ man also eine
Seite 198 und 199: 186 9. Klassen in C++ 77 78 cout
Seite 200 und 201: 188 9. Klassen in C++ Die Antwort,
Seite 202 und 203: 190 9. Klassen in C++ 29 30 //−
Seite 204 und 205: 192 9. Klassen in C++ 85 86 return
Seite 206 und 207: 194 9. Klassen in C++ ist sie nicht
Seite 208 und 209: 196 9. Klassen in C++ number o f ca
Seite 210 und 211: 198 9. Klassen in C++ 10 ∗ a gene
Seite 212 und 213: 200 9. Klassen in C++ 52 { 53 v i s
Seite 214 und 215: 202 9. Klassen in C++ die Rückseit
Seite 216 und 217: 204 9. Klassen in C++ wir kurz: Uns
Seite 218 und 219: 206 9. Klassen in C++ Die sinnvolle
Seite 220 und 221: 208 9. Klassen in C++ Implementatio
Seite 222 und 223: 210 9. Klassen in C++ 27 } ; 28 29
Seite 224 und 225: 212 9. Klassen in C++ 93 ∗ @retur
Seite 226 und 227: 214 9. Klassen in C++ Bei der Imple
Seite 228 und 229: 216 9. Klassen in C++ 51 DerivedCla
Seite 230 und 231: 218 9. Klassen in C++ 46 DerivedCla
Seite 232 und 233: 220 9. Klassen in C++ auch darum k
Seite 234 und 235: 222 9. Klassen in C++ Der Output di
Seite 236 und 237: 224 9. Klassen in C++ 1 // static d
Seite 238 und 239: 226 9. Klassen in C++ tatsächlich
Seite 240 und 241: 228 9. Klassen in C++ 93 cout
Seite 244 und 245: 232 9. Klassen in C++ aufgebaut. So
Seite 246 und 247: 234 9. Klassen in C++ Das bringt un
Seite 248 und 249: 236 9. Klassen in C++ anderen Aspek
Seite 250 und 251: 238 9. Klassen in C++ bedeutet das
Seite 252 und 253: 240 9. Klassen in C++ 198 GameCard
Seite 254 und 255: 242 9. Klassen in C++ 14 ∗ 15 ∗
Seite 256 und 257: 244 9. Klassen in C++ 146 { 147 con
Seite 258 und 259: 246 9. Klassen in C++ einen Gedanke
Seite 260 und 261: 248 9. Klassen in C++ suchen müsse
Seite 262 und 263: 250 9. Klassen in C++ Betrachtet ma
Seite 264 und 265: 252 9. Klassen in C++ 7 ∗ 8 ∗ j
Seite 266 und 267: 254 9. Klassen in C++ 5. Im letzten
Seite 268 und 269: 256 9. Klassen in C++ 3. Im Zuge de
Seite 270 und 271: 258 10. Memory - ein kleines Beispi
Seite 292 und 293:
280 10. Memory - ein kleines Beispi
Seite 294 und 295:
Seite 296 und 297:
Seite 298 und 299:
Seite 300 und 301:
Seite 302 und 303:
Seite 304 und 305:
Seite 306 und 307:
Seite 308 und 309:
Seite 310 und 311:
Seite 312 und 313:
Seite 314 und 315:
Seite 316 und 317:
Seite 318 und 319:
Seite 320 und 321:
Seite 323 und 324:
11. Exceptions In den bisherigen Be
Seite 325 und 326:
22 uint32 my id ; 23 public : 24 Ex
Seite 327 und 328:
154 11. Exceptions 315 155 //−−
Seite 329 und 330:
11. Exceptions 317 geschwindigkeits
Seite 331 und 332:
11. Exceptions 319 ser auch verwend
Seite 333 und 334:
57 11. Exceptions 321 58 //−−
Seite 335 und 336:
11. Exceptions 323 Vorsicht Falle:
Seite 337 und 338:
46 } 47 catch ( Exception &exc ) 48
Seite 339 und 340:
11. Exceptions 327 Objekte in ihrem
Seite 341 und 342:
11. Exceptions 329 Der Grund hierf
Seite 343 und 344:
11. Exceptions 331 16 virtual ˜ Ex
Seite 345:
11. Exceptions 333 lange Zeit gäng
Seite 348 und 349:
336 12. Operator Overloading • Po
Seite 350 und 351:
338 12. Operator Overloading 49 thr
Seite 352 und 353:
340 12. Operator Overloading erzeug
Seite 354 und 355:
342 12. Operator Overloading In den
Seite 356 und 357:
344 12. Operator Overloading 5 Math
Seite 358 und 359:
346 12. Operator Overloading In den
Seite 360 und 361:
348 12. Operator Overloading 216 do
Seite 362 und 363:
350 12. Operator Overloading 15 Mat
Seite 364 und 365:
352 12. Operator Overloading Je meh
Seite 366 und 367:
354 12. Operator Overloading MathVe
Seite 368 und 369:
356 12. Operator Overloading 39 40
Seite 370 und 371:
358 12. Operator Overloading 12 6 1
Seite 372 und 373:
360 12. Operator Overloading der Fo
Seite 374 und 375:
362 12. Operator Overloading verges
Seite 376 und 377:
364 12. Operator Overloading zu wei
Seite 378 und 379:
366 12. Operator Overloading werden
Seite 380 und 381:
368 12. Operator Overloading Eine K
Seite 382 und 383:
370 12. Operator Overloading Pool v
Seite 384 und 385:
372 12. Operator Overloading 191 vo
Seite 386 und 387:
374 12. Operator Overloading aufger
Seite 388 und 389:
376 12. Operator Overloading 120 th
Seite 390 und 391:
378 12. Operator Overloading Was si
Seite 392 und 393:
380 12. Operator Overloading Sollte
Seite 394 und 395:
382 12. Operator Overloading hilft
Seite 396 und 397:
384 12. Operator Overloading 130 13
Seite 398 und 399:
386 12. Operator Overloading 46 /
Seite 400 und 401:
388 12. Operator Overloading 208 co
Seite 402 und 403:
390 12. Operator Overloading 146 //
Seite 404 und 405:
392 12. Operator Overloading 10 usi
Seite 406 und 407:
394 12. Operator Overloading Das Me
Seite 408 und 409:
396 12. Operator Overloading 84 } ;
Seite 410 und 411:
398 12. Operator Overloading 25 i f
Seite 412 und 413:
400 12. Operator Overloading memory
Seite 414 und 415:
402 12. Operator Overloading Intere
Seite 417 und 418:
13. Templates Bevor wir überhaupt
Seite 419 und 420:
13.1 Function Templates 13.1 Functi
Seite 421 und 422:
findMax f o r int32 array . . . max
Seite 423 und 424:
13.1 Function Templates 411 CD-ROM
Seite 425 und 426:
13.1 Function Templates 413 keiten
Seite 427 und 428:
13.2 Overloading Aspekte von Functi
Seite 429 und 430:
13.2 Overloading Aspekte von Functi
Seite 431 und 432:
16 cout
Seite 433 und 434:
13.3 Class Templates 421 prägung e
Seite 435 und 436:
13.3 Class Templates 423 der die al
Seite 437 und 438:
13.3 Class Templates 425 Ein Blick
Seite 439 und 440:
13.3 Class Templates 427 Wenn man s
Seite 441 und 442:
13.4 Ableiten von Class Templates 4
Seite 443 und 444:
1 class QueryableFloatBuffer : 2 pu
Seite 445 und 446:
25 uint32 num elements allocated ;
Seite 447 und 448:
14 15 int32 i n t e g e r s [ ] = {
Seite 449 und 450:
13.5 Explizite Spezialisierungen 43
Seite 451 und 452:
35 i n t 3 2 p t r b u f f e r . pu
Seite 453 und 454:
s p e c i a l i z e d d e s t r u
Seite 455 und 456:
13.5 Explizite Spezialisierungen 44
Seite 457 und 458:
35 return (∗ this ) ; 36 } 37 38
Seite 459 und 460:
13.7 Source Code Organisation 447 D
Seite 461 und 462:
13.7 Source Code Organisation 449 D
Seite 463:
18 GenericStorage double storage (
Seite 466 und 467:
454 14. Namespaces gemeinsamen Name
Seite 468 und 469:
456 14. Namespaces 33 uint32 num el
Seite 470 und 471:
458 14. Namespaces 39 Datastructure
Seite 472 und 473:
460 14. Namespaces zu vermeiden. Du
Seite 475 und 476:
15. Verschiedenes In diesem Kapitel
Seite 477 und 478:
15.2 Unions im OO Kontext 465 an ob
Seite 479 und 480:
92 } 93 15.2 Unions im OO Kontext 4
Seite 481 und 482:
15.2 Unions im OO Kontext 469 durch
Seite 483 und 484:
53 { 54 uint32 ( ∗ calcFunction )
Seite 485 und 486:
42 15.3 Funktionspointer 473 43 //
Seite 487 und 488:
15.4 Besondere Keywords, Diagraphs
Seite 489 und 490:
15.5 volatile Objekte 15.6 RTTI und
Seite 491 und 492:
15.6 RTTI und dynamic cast im OO Ko
Seite 493 und 494:
15.6 RTTI und dynamic cast im OO Ko
Seite 495 und 496:
15.7 Weiterführendes zu Exceptions
Seite 497 und 498:
Seite 499 und 500:
Seite 501 und 502:
32 throw OneException ( ) ; 33 } 34
Seite 503:
Teil III Ausgesuchte Teile aus der
Seite 506 und 507:
494 16. Die C++ Standard Library be
Seite 508 und 509:
496 16. Die C++ Standard Library 1.
Seite 510 und 511:
498 16. Die C++ Standard Library 34
Seite 512 und 513:
Seite 514 und 515:
Seite 516 und 517:
Seite 518 und 519:
506 16. Die C++ Standard Library al
Seite 520 und 521:
508 16. Die C++ Standard Library da
Seite 522 und 523:
510 16. Die C++ Standard Library ze
Seite 524 und 525:
512 16. Die C++ Standard Library As
Seite 526 und 527:
514 16. Die C++ Standard Library Pr
Seite 528 und 529:
Seite 530 und 531:
518 16. Die C++ Standard Library Au
Seite 532 und 533:
520 16. Die C++ Standard Library Ch
Seite 534 und 535:
522 16. Die C++ Standard Library ta
Seite 536 und 537:
Seite 538 und 539:
Seite 540 und 541:
528 16. Die C++ Standard Library ba
Seite 542 und 543:
Seite 544 und 545:
532 16. Die C++ Standard Library nu
Seite 546 und 547:
534 16. Die C++ Standard Library es
Seite 549 und 550:
A. Coding-Standard Der hier angefü
Seite 551 und 552:
A.2 Coding-Rules 539 • C-Style Ca
Seite 553:
A.3 Design Guidelines 541 erwartet
Seite 556 und 557:
544 B. Vollständige Implementation
Seite 558 und 559:
Seite 560 und 561:
Seite 562 und 563:
Seite 564 und 565:
Seite 566 und 567:
Seite 568 und 569:
Seite 570 und 571:
Seite 572 und 573:
Seite 575 und 576:
Index ? :, 75 #define, 138 #else, 1
Seite 577 und 578:
double, 13, 18 double Precision, 18
Seite 579 und 580:
- new[], 371 - Typumwandlung, 354 -
Seite 581:
unsigned short, 17 unsigned short i
Alle anzeigen

Softwareentwicklung in C++ - ASC

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?