 |
| C++ Annotations Version 10.1.0 by Frank B. Brokken |E-Book |
Table of Contents:
2 Introduction ................................................................................................. 3
2.1 What’s new in the C++ Annotations . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 C++’s history . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.3 C++: advantages and claims . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4 What is Object-Oriented Programming? . . . . . . . . . . . . . . . . . . . . . . 11
2.5 Differences between C and C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3 A First Impression Of C++......................................................................... 25
3.1 Extensions to C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.2 Functions as part of structs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.3 More extensions to C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.4 New language-defined data types . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.5 A new syntax for casts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.6 Keywords and reserved names in C++ . . . . . . . . . . . . . . . . . . . . . . . . 56
4 Name Spaces ..................................................................................................57
5 The ‘string’ Data Type ...................................................................................69
5.1 Operations on strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.2 A std::string reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
6 The IO-stream Library..................................................................................... 85
6.1 Special header files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88
6.2 The foundation: the class ‘ios_base’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . .89
6.3 Interfacing ‘streambuf’ objects: the class ‘ios’ . . . . . . . . . . . . . . . . . . . . .89
6.4 Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .100
6.5 Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
6.6 Advanced topics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
7 Classes .................................................................................................................123
7.1 The constructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .125
7.2 Ambiguity resolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
7.3 Objects inside objects: composition . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
7.4 Data member initializers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
7.5 Uniform initialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
7.6 Defaulted and deleted class members . . . . . . . . . . . . . . . . . . . . . . . . . . . .144
7.7 Const member functions and const objects . . . . . . . . . . . . . . . . . . . . . . . . 145
7.8 Member function reference bindings (& and &&) . . . . . . . . . . . . . . . . . . 150
7.9 The keyword ‘inline’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
7.10 Local classes: classes inside functions . . . . . . . . . . . . . . . . . . . . . . . . . . 153
7.11 The keyword ‘mutable’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .155
7.12 Header file organization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
8 Static Data And Functions ..................................................................................163
8.1 Static data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
8.2 Static member functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 170
9 Classes And Memory Allocation...................................................................... 175
9.1 Operators ‘new’ and ‘delete’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176
9.2 The destructor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
9.3 The assignment operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .189
10 Exceptions .......................................................................................................... 217
10.1 Exception syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
10.2 An example using exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
10.3 Throwing exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
10.4 The try block . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
10.5 Catching exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
10.6 Declaring exception throwers (deprecated) . . . . . . . . . . . . . . . . . . . . . . . 232
10.7 Iostreams and exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
10.8 Standard Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
10.9 System error, error code and error category . . . . . . . . . . . . . . . . . . . . . . . 237
11 More Operator Overloading................................................................................. 257
11.1 Overloading ‘operator[]()’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .257
11.2 Overloading the insertion and extraction operators . . . . . . . . . . . . . . . . . . 260
11.3 Conversion operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
11.4 The keyword ‘explicit’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265
11.5 Overloading the increment and decrement operators . . . . . . . . . . . . . . . . . 267
11.6 Overloading binary operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
11.7 Overloading ‘operator new(size_t)’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
11.8 Overloading ‘operator delete(void *)’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
11.9 Operators ‘new[]’ and ‘delete[]’ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
12 Abstract Containers ..........................................................................................293
12.1 Notations used in this chapter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
12.2 The ‘pair’ container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .296
12.3 Allocators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
12.4 Available Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
12.5 The ‘complex’ container . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345
12.6 Unrestricted Unions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
13 Inheritance ............................................................................................................355
13.1 Related types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
13.2 Access rights: public, private, protected . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
13.3 The constructor of a derived class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
13.4 The destructor of a derived class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
13.5 Redefining member functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
13.6 i/ostream::init . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
13.7 Multiple inheritance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
13.8 Conversions between base classes and derived classes . . . . . . . . . . . . . . . . 373
14 Polymorphism ...............................................................................................381
14.1 Virtual functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
14.2 Virtual destructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
14.3 Pure virtual functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
15 Friends ...........................................................................................................427
15.1 Friend functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428
15.2 Extended friend declarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
16 Classes Having Pointers To Members............................................................... 431
16.1 Pointers to members: an example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . 431
16.2 Defining pointers to members . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
16.3 Using pointers to members . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
16.4 Pointers to static members . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437
16.5 Pointer sizes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438
17 Nested Classes ....................................................................................................441
17.1 Defining nested class members . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
17.2 Declaring nested classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
17.3 Accessing private members in nested classes . . . . . . . . . . . . . . . . . . . . . 444
17.4 Nesting enumerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
18 The Standard Template Library ...........................................................................453
18.1 Predefined function objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . 453
18.2 Iterators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . . . . . . . . . . . . . 463
19 The STL Generic Algorithms .................................................................................525
20 Multi Threading....................................................................................................... 609
21 Function Templates.................................................................................................. 679
22 Class Templates........................................................................................................ 721
23 Advanced Template Use.......................................................................................... 815
24 Concrete Examples.................................................................................................. 877
