C++ Annotations Version 9.9.1

Frank B. Brokken

Center of Information Technology,
University of Groningen
Nettelbosje 1,
P.O. Box 11044,
9700 CA Groningen
The Netherlands
Published at the University of Groningen
ISBN 90 367 0470 7

1994 - 2014

This document is intended for knowledgeable users of C (or any other language using a C-like grammar, like Perl or Java) who would like to know more about, or make the transition to, C++. This document is the main textbook for Frank's C++ programming courses, which are yearly organized at the University of Groningen. The C++ Annotations do not cover all aspects of C++, though. In particular, C++'s basic grammar is not covered when equal to C's grammar. Any basic book on C may be consulted to refresh that part of C++'s grammar.

If you want a hard-copy version of the C++ Annotations: printable versions are available in postscript, pdf and other formats in

in files having names starting with cplusplus (A4 paper size). Files having names starting with `cplusplusus' are intended for the US legal paper size. The C++ Annotations are also available as a Kindle book.

The latest version of the C++ Annotations in html-format can be browsed at:

and/or at

Table of Contents

Chapter 1: Overview Of The Chapters

Chapter 2: Introduction

2.1: What's new in the C++ Annotations

2.2: C++'s history

2.2.1: History of the C++ Annotations
2.2.2: Compiling a C program using a C++ compiler
2.2.3: Compiling a C++ program C++ under MS-Windows Compiling a C++ source text

2.3: C++: advantages and claims

2.4: What is Object-Oriented Programming?

2.5: Differences between C and C++

2.5.1: The function `main'
2.5.2: End-of-line comment
2.5.3: Strict type checking
2.5.4: Function Overloading
2.5.5: Default function arguments
2.5.6: NULL-pointers vs. 0-pointers and nullptr
2.5.7: The `void' parameter list
2.5.8: The `#define __cplusplus'
2.5.9: Using standard C functions
2.5.10: Header files for both C and C++
2.5.11: Defining local variables
2.5.12: The keyword `typedef'
2.5.13: Functions as part of a struct

Chapter 3: A First Impression Of C++

3.1: Extensions to C

3.1.1: Namespaces
3.1.2: The scope resolution operator ::
3.1.3: Using the keyword `const'
3.1.4: `cout', `cin', and `cerr'

3.2: Functions as part of structs

3.2.1: Data hiding: public, private and class
3.2.2: Structs in C vs. structs in C++

3.3: More extensions to C

3.3.1: References
3.3.2: Rvalue References
3.3.3: Strongly typed enumerations
3.3.4: Initializer lists
3.3.5: Type inference using `auto'
3.3.6: Defining types and 'using' declarations
3.3.7: Range-based for-loops
3.3.8: Raw String Literals

3.4: New language-defined data types

3.4.1: The data type `bool'
3.4.2: The data type `wchar_t'
3.4.3: Unicode encoding
3.4.4: The data type `long long int'
3.4.5: The data type `size_t'

3.5: A new syntax for casts

3.5.1: The `static_cast'-operator
3.5.2: The `const_cast'-operator
3.5.3: The `reinterpret_cast'-operator
3.5.4: The `dynamic_cast'-operator
3.5.5: Casting 'shared_ptr' objects

3.6: Keywords and reserved names in C++

Chapter 4: Name Spaces

4.1: Namespaces

4.1.1: Defining namespaces Declaring entities in namespaces A closed namespace
4.1.2: Referring to entities The `using' directive `Koenig lookup'
4.1.3: The standard namespace
4.1.4: Nesting namespaces and namespace aliasing Defining entities outside of their namespaces

Chapter 5: The `string' Data Type

5.1: Operations on strings

5.2: A std::string reference

5.2.1: Initializers
5.2.2: Iterators
5.2.3: Operators
5.2.4: Member functions
5.2.5: Conversion functions

Chapter 6: The IO-stream Library

6.1: Special header files

6.2: The foundation: the class `ios_base'

6.3: Interfacing `streambuf' objects: the class `ios'

6.3.1: Condition states
6.3.2: Formatting output and input Format modifying member functions Formatting flags

6.4: Output

6.4.1: Basic output: the class `ostream' Writing to `ostream' objects `ostream' positioning `ostream' flushing
6.4.2: Output to files: the class `ofstream' Modes for opening stream objects
6.4.3: Output to memory: the class `ostringstream'

6.5: Input

6.5.1: Basic input: the class `istream' Reading from `istream' objects `istream' positioning
6.5.2: Input from files: the class `ifstream'
6.5.3: Input from memory: the class `istringstream'
6.5.4: Copying streams
6.5.5: Coupling streams

6.6: Advanced topics

6.6.1: Redirecting streams
6.6.2: Reading AND Writing streams

Chapter 7: Classes

7.1: The constructor

7.1.1: A first application
7.1.2: Constructors: with and without arguments The order of construction

7.2: Ambiguity resolution

7.2.1: Types `Data' vs. `Data()'
7.2.2: Superfluous parentheses
7.2.3: Existing types

7.3: Objects inside objects: composition

7.3.1: Composition and const objects: const member initializers
7.3.2: Composition and reference objects: reference member initializers

7.4: Data member initializers

7.4.1: Delegating constructors

7.5: Uniform initialization

7.6: Defaulted and deleted class members

7.7: Const member functions and const objects

7.7.1: Anonymous objects Subtleties with anonymous objects

7.8: The keyword `inline'

7.8.1: Defining members inline
7.8.2: When to use inline functions A prelude: when NOT to use inline functions

7.9: Local classes: classes inside functions

7.10: The keyword `mutable'

7.11: Header file organization

7.11.1: Using namespaces in header files

7.12: Sizeof applied to class data members

Chapter 8: Static Data And Functions

8.1: Static data

8.1.1: Private static data
8.1.2: Public static data
8.1.3: Initializing static const data
8.1.4: Generalized constant expressions (constexpr) Constant expression data

8.2: Static member functions

8.2.1: Calling conventions

Chapter 9: Classes And Memory Allocation

9.1: Operators `new' and `delete'

9.1.1: Allocating arrays
9.1.2: Deleting arrays
9.1.3: Enlarging arrays
9.1.4: Managing `raw' memory
9.1.5: The `placement new' operator

9.2: The destructor

9.2.1: Object pointers revisited
9.2.2: The function set_new_handler()

9.3: The assignment operator

9.3.1: Overloading the assignment operator The member 'operator=()'

9.4: The `this' pointer

9.4.1: Sequential assignments and this

9.5: The copy constructor: initialization vs. assignment

9.6: Revising the assignment operator

9.6.1: Swapping Fast swapping

9.7: Moving data

9.7.1: The move constructor (dynamic data)
9.7.2: The move constructor (composition)
9.7.3: Move-assignment
9.7.4: Revising the assignment operator (part II)
9.7.5: Moving and the destructor
9.7.6: Move-only classes
9.7.7: Default move constructors and assignment operators
9.7.8: Moving: implications for class design

9.8: Copy Elision and Return Value Optimization

9.9: Plain Old Data

9.10: Conclusion

Chapter 10: Exceptions

10.1: Exception syntax

10.2: An example using exceptions

10.2.1: Anachronisms: `setjmp' and `longjmp'
10.2.2: Exceptions: the preferred alternative

10.3: Throwing exceptions

10.3.1: The empty `throw' statement

10.4: The try block

10.5: Catching exceptions

10.5.1: The default catcher

10.6: Declaring exception throwers (deprecated)

10.7: Iostreams and exceptions

10.8: Standard Exceptions

10.9: System error, error code and error category

10.9.1: The class `error_code'
10.9.2: The class `error_category'

10.10: Exception guarantees

10.10.1: The basic guarantee
10.10.2: The strong guarantee
10.10.3: The nothrow guarantee

10.11: Function try blocks

10.12: Exceptions in constructors and destructors

Chapter 11: More Operator Overloading

11.1: Overloading `operator[]()'

11.2: Overloading the insertion and extraction operators

11.3: Conversion operators

11.4: The keyword `explicit'

11.4.1: Explicit conversion operators

11.5: Overloading the increment and decrement operators

11.6: Overloading binary operators

11.7: Overloading `operator new(size_t)'

11.8: Overloading `operator delete(void *)'

11.9: Operators `new[]' and `delete[]'

11.9.1: Overloading `new[]'
11.9.2: Overloading `delete[]'
11.9.3: `new[]', `delete[]' and exceptions

11.10: Function Objects

11.10.1: Constructing manipulators Manipulators requiring arguments

11.11: The case of [io]fstream::open()

11.12: User-defined literals

11.13: Overloadable operators

Chapter 12: Abstract Containers

12.1: Notations used in this chapter

12.2: The `pair' container

12.3: Allocators

12.4: Available Containers

12.4.1: ARRAY
12.4.2: The `vector' container
12.4.3: The `list' container
12.4.4: The `queue' container
12.4.5: The `priority_queue' container
12.4.6: The `deque' container
12.4.7: The `map' container The `map' constructors The `map' operators The `map' public members The `map': a simple example
12.4.8: The `multimap' container
12.4.9: The `set' container
12.4.10: The `multiset' container
12.4.11: The `stack' container
12.4.12: The `unordered_map' container (`hash table') The `unordered_map' constructors The `unordered_map' public members The `unordered_multimap' container
12.4.13: The `unordered_set' container The `unordered_multiset' container

12.5: Regular Expressions

12.6: The `complex' container

12.7: Unrestricted Unions

12.7.1: Implementing the destructor
12.7.2: Embedding an unrestricted union in a surrounding class
12.7.3: Destroying an embedded unrestricted union
12.7.4: Copy and move constructors
12.7.5: Assignment

Chapter 13: Inheritance

13.1: Related types

13.1.1: Inheritance depth: desirable?

13.2: Access rights: public, private, protected

13.2.1: Public, protected and private derivation
13.2.2: Promoting access rights

13.3: The constructor of a derived class

13.3.1: Move construction
13.3.2: Move assignment
13.3.3: Inheriting constructors

13.4: The destructor of a derived class

13.5: Redefining member functions

13.6: i/ostream::init

13.7: Multiple inheritance

13.8: Conversions between base classes and derived classes

13.8.1: Conversions with object assignments
13.8.2: Conversions with pointer assignments

13.9: Using non-default constructors with new[]

Chapter 14: Polymorphism

14.1: Virtual functions

14.2: Virtual destructors

14.3: Pure virtual functions

14.3.1: Implementing pure virtual functions

14.4: Explicit virtual overrides

14.5: Virtual functions and multiple inheritance

14.5.1: Ambiguity in multiple inheritance
14.5.2: Virtual base classes
14.5.3: When virtual derivation is not appropriate

14.6: Run-time type identification

14.6.1: The dynamic_cast operator
14.6.2: The `typeid' operator

14.7: Inheritance: when to use to achieve what?

14.8: The `streambuf' class

14.8.1: Protected `streambuf' members Protected members for input operations Protected members for output operations Protected members for buffer manipulation Deriving classes from `streambuf'
14.8.2: The class `filebuf'

14.9: A polymorphic exception class

14.10: How polymorphism is implemented

14.11: Undefined reference to vtable ...

14.12: Virtual constructors

Chapter 15: Friends

15.1: Friend functions

15.2: Extended friend declarations

Chapter 16: Classes Having Pointers To Members

16.1: Pointers to members: an example

16.2: Defining pointers to members

16.3: Using pointers to members

16.4: Pointers to static members

16.5: Pointer sizes

Chapter 17: Nested Classes

17.1: Defining nested class members

17.2: Declaring nested classes

17.3: Accessing private members in nested classes

17.4: Nesting enumerations

17.4.1: Empty enumerations

17.5: Revisiting virtual constructors

Chapter 18: The Standard Template Library

18.1: Predefined function objects

18.1.1: Arithmetic function objects
18.1.2: Relational function objects
18.1.3: Logical function objects
18.1.4: Function adaptors Binders Negators

18.2: Iterators

18.2.1: Insert iterators
18.2.2: Iterators for `istream' objects Iterators for `istreambuf' objects
18.2.3: Iterators for `ostream' objects Iterators for `ostreambuf' objects

18.3: The class 'unique_ptr'

18.3.1: Defining `unique_ptr' objects
18.3.2: Creating a plain `unique_ptr'
18.3.3: Moving another `unique_ptr'
18.3.4: Pointing to a newly allocated object
18.3.5: Operators and members
18.3.6: Using `unique_ptr' objects for arrays
18.3.7: The legacy class 'auto_ptr' (deprecated)

18.4: The class 'shared_ptr'

18.4.1: Defining `shared_ptr' objects
18.4.2: Creating a plain `shared_ptr'
18.4.3: Pointing to a newly allocated object
18.4.4: Operators and members
18.4.5: Casting shared pointers
18.4.6: Using `shared_ptr' objects for arrays

18.5: Using `make_shared' to combine `shared_ptr' and `new'

18.6: Classes having pointer data members

18.7: Specifying time (absolute and relative)

18.7.1: Time units: the class 'ratio'
18.7.2: An amount of time: the class 'duration'
18.7.3: Clocks measuring time
18.7.4: Points in time: the class 'time_point'

18.8: Multi Threading

18.8.1: The namespace `std::this_thread'
18.8.2: The class `std::thread'
18.8.3: Synchronization (mutexes)
18.8.4: Locks and lock handling Deadlocks
18.8.5: Event handling (condition variables) The class 'condition_variable' The class 'condition_variable_any' An example using condition variables

18.9: Lambda expressions

18.10: Randomization and Statistical Distributions

18.10.1: Random Number Generators
18.10.2: Statistical distributions Bernoulli distribution Binomial distribution Cauchy distribution Chi-squared distribution Extreme value distribution Exponential distribution Fisher F distribution Gamma distribution Geometric distribution Log-normal distribution Normal distribution Negative binomial distribution Poisson distribution Student t distribution Uniform int distribution Uniform real distribution Weibull distribution

Chapter 19: The STL Generic Algorithms

19.1: The Generic Algorithms

19.1.1: accumulate
19.1.2: adjacent_difference
19.1.3: adjacent_find
19.1.4: binary_search
19.1.5: copy
19.1.6: copy_backward
19.1.7: count
19.1.8: count_if
19.1.9: equal
19.1.10: equal_range
19.1.11: fill
19.1.12: fill_n
19.1.13: find
19.1.14: find_end
19.1.15: find_first_of
19.1.16: find_if
19.1.17: for_each
19.1.18: generate
19.1.19: generate_n
19.1.20: includes
19.1.21: inner_product
19.1.22: inplace_merge
19.1.23: iter_swap
19.1.24: lexicographical_compare
19.1.25: lower_bound
19.1.26: max
19.1.27: max_element
19.1.28: merge
19.1.29: min
19.1.30: min_element
19.1.31: mismatch
19.1.32: next_permutation
19.1.33: nth_element
19.1.34: partial_sort
19.1.35: partial_sort_copy
19.1.36: partial_sum
19.1.37: partition
19.1.38: prev_permutation
19.1.39: random_shuffle
19.1.40: remove
19.1.41: remove_copy
19.1.42: remove_copy_if
19.1.43: remove_if
19.1.44: replace
19.1.45: replace_copy
19.1.46: replace_copy_if
19.1.47: replace_if
19.1.48: reverse
19.1.49: reverse_copy
19.1.50: rotate
19.1.51: rotate_copy
19.1.52: search
19.1.53: search_n
19.1.54: set_difference
19.1.55: set_intersection
19.1.56: set_symmetric_difference
19.1.57: set_union
19.1.58: sort
19.1.59: stable_partition
19.1.60: stable_sort
19.1.61: swap
19.1.62: swap_ranges
19.1.63: transform
19.1.64: unique
19.1.65: unique_copy
19.1.66: upper_bound
19.1.67: Heap algorithms The `make_heap' function The `pop_heap' function The `push_heap' function The `sort_heap' function An example using the heap functions

19.2: STL: More function adaptors

19.2.1: Member function adaptors
19.2.2: Adaptable functions

Chapter 20: Function Templates

20.1: Defining function templates

20.1.1: Considerations regarding template parameters
20.1.2: Late-specified return type

20.2: Passing arguments by reference (reference wrappers)

20.3: Using Local and unnamed types as template arguments

20.4: Template parameter deduction

20.4.1: Lvalue transformations
20.4.2: Qualification transformations
20.4.3: Transformation to a base class
20.4.4: The template parameter deduction algorithm
20.4.5: Template type contractions

20.5: Declaring function templates

20.5.1: Instantiation declarations

20.6: Instantiating function templates

20.6.1: Instantiations: no `code bloat'

20.7: Using explicit template types

20.8: Overloading function templates

20.8.1: An example using overloaded function templates
20.8.2: Ambiguities when overloading function templates
20.8.3: Declaring overloaded function templates

20.9: Specializing templates for deviating types

20.9.1: Avoiding too many specializations
20.9.2: Declaring specializations
20.9.3: Complications when using the insertion operator

20.10: Static assertions

20.11: Numeric limits

20.12: Polymorphous wrappers for function objects

20.13: Compiling template definitions and instantiations

20.14: The function selection mechanism

20.15: Determining the template type parameters

20.16: SFINAE: Substitution Failure Is Not An Error

20.17: Summary of the template declaration syntax

Chapter 21: Class Templates

21.1: Defining class templates

21.1.1: Constructing the circular queue: CirQue
21.1.2: Non-type parameters
21.1.3: Member templates
21.1.4: CirQue's constructors and member functions
21.1.5: Using CirQue objects
21.1.6: Default class template parameters
21.1.7: Declaring class templates
21.1.8: Preventing template instantiations

21.2: Static data members

21.2.1: Extended use of the keyword `typename'

21.3: Specializing class templates for deviating types

21.3.1: Example of a class specialization

21.4: Partial specializations

21.4.1: Intermezzo: some simple matrix algebraic concepts
21.4.2: The Matrix class template
21.4.3: The MatrixRow partial specialization
21.4.4: The MatrixColumn partial specialization
21.4.5: The 1x1 matrix: avoid ambiguity

21.5: Variadic templates

21.5.1: Defining and using variadic templates
21.5.2: Perfect forwarding References to references
21.5.3: The unpack operator
21.5.4: Non-type variadic templates

21.6: Tuples

21.7: Computing the return type of function objects

21.8: Instantiating class templates

21.9: Processing class templates and instantiations

21.10: Declaring friends

21.10.1: Non-templates used as friends in templates
21.10.2: Templates instantiated for specific types as friends
21.10.3: Unbound templates as friends
21.10.4: Extended friend declarations

21.11: Class template derivation

21.11.1: Deriving ordinary classes from class templates
21.11.2: Deriving class templates from class templates
21.11.3: Deriving class templates from ordinary classes

21.12: Static Polymorphism

21.12.1: An example of static polymorphism
21.12.2: Converting dynamic polymorphic classes to static polymorphic classes
21.12.3: Using static polymorphism to avoid reimplementations

21.13: Class templates and nesting

21.14: Constructing iterators

21.14.1: Implementing a `RandomAccessIterator'
21.14.2: Implementing a `reverse_iterator'

Chapter 22: Advanced Template Use

22.1: Subtleties

22.1.1: Returning types nested under class templates
22.1.2: Type resolution for base class members
22.1.3: ::template, .template and ->template

22.2: Template Meta Programming

22.2.1: Values according to templates Converting integral types to types
22.2.2: Selecting alternatives using templates Defining overloading members Class structure as a function of template parameters An illustrative example
22.2.3: Templates: Iterations by Recursion

22.3: User-defined literals

22.4: Template template parameters

22.4.1: Policy classes - I
22.4.2: Policy classes - II: template template parameters The destructor of Policy classes
22.4.3: Structure by Policy

22.5: Template aliases

22.6: Trait classes

22.6.1: Distinguishing class from non-class types
22.6.2: Available type traits

22.7: Using `noexcept' when offering the `strong guarantee'

22.8: More conversions to class types

22.8.1: Types to types
22.8.2: An empty type
22.8.3: Type convertibility Determining inheritance

22.9: Template TypeList processing

22.9.1: The length of a TypeList
22.9.2: Searching a TypeList
22.9.3: Selecting from a TypeList
22.9.4: Prefixing/Appending to a TypeList
22.9.5: Erasing from a TypeList Erasing the first occurrence Erasing a type by its index Erasing all occurrences of a type Erasing duplicates

22.10: Using a TypeList

22.10.1: The Wrap and Multi class templates
22.10.2: The MultiBase class template
22.10.3: Support templates
22.10.4: Using Multi

Chapter 23: Concrete Examples

23.1: Using file descriptors with `streambuf' classes

23.1.1: Classes for output operations
23.1.2: Classes for input operations Using a one-character buffer Using an n-character buffer Seeking positions in `streambuf' objects Multiple `unget' calls in `streambuf' objects
23.1.3: Fixed-sized field extraction from istream objects Member functions and example

23.2: The `fork' system call

23.2.1: A basic Fork class
23.2.2: Parents and Children
23.2.3: Redirection revisited
23.2.4: The `Daemon' program
23.2.5: The class `Pipe'
23.2.6: The class `ParentSlurp'
23.2.7: Communicating with multiple children The class `Selector': interface The class `Selector': implementation The class `Monitor': interface The class `Monitor': s_handler The class `Monitor': the member `run' The class `Monitor': example The class `Child'

23.3: Function objects performing bitwise operations

23.4: Adding binary operators to classes

23.4.1: Binary operators allowing promotions

23.5: Range-based for-loops and pointer-ranges

23.6: Distinguishing lvalues from rvalues with operator[]()

23.7: Implementing a `reverse_iterator'

23.8: Using `bisonc++' and `flexc++'

23.8.1: Using `flexc++' to create a scanner The derived class `Scanner' The lexical scanner specification file Implementing `Scanner' Using a `Scanner' object Building the program
23.8.2: Using `bisonc++' and `flexc++' The `bisonc++' specification file The `flexc++' specification file Building the program
23.8.3: Bisonc++: using polymorphic semantic values The parser using a polymorphic semantic value type Tagging the actual semantic type: the `enum class Tag' (Im)mutable semantic data: two base-structs Traits of semantic type tags: the `TagTrait' trait class Accessing data from derived classes The polymorphic base class `SemBase' The class template `Semantic', derived from `SemBase' Adding new semantic data types The parser's semantic value: `spSemBase' The parser specification file The scanner using a polymorphic semantic value type