C++ Annotations

Overview Of The Chapters
Introduction
What's new in the C++ Annotations
C++'s history
History of the C++ Annotations
Compiling a C program using a C++ compiler
Compiling a C++ program
C++: advantages and claims
What is Object-Oriented Programming?
Differences between C and C++
The function `main'
End-of-line comment
Strict type checking
Function Overloading
Default function arguments
NULL-pointers vs. 0-pointers and nullptr (C++11)
The `void' parameter list
The `#define __cplusplus'
Using standard C functions
Header files for both C and C++
Defining local variables
The keyword `typedef'
Functions as part of a struct
A First Impression Of C++
Extensions to C
Namespaces
The scope resolution operator ::
Using the keyword `const'
`cout', `cin', and `cerr'
Functions as part of structs
Data hiding: public, private and class
Structs in C vs. structs in C++
More extensions to C
References
Rvalue References (C++11)
Strongly typed enumerations (C++11)
Initializer lists (C++11)
Type inference using `auto' (C++11)
Defining types and 'using' declarations (C++11, 4.7)
Range-based for-loops (C++11)
Raw String Literals (C++11)
New language-defined data types
The data type `bool'
The data type `wchar_t'
Unicode encoding (C++11)
The data type `long long int' (C++11)
The data type `size_t'
A new syntax for casts
The `static_cast'-operator
The `const_cast'-operator
The `reinterpret_cast'-operator
The `dynamic_cast'-operator
Keywords and reserved names in C++
Name Spaces
Namespaces
Defining namespaces
Referring to entities
The standard namespace
Nesting namespaces and namespace aliasing
The `string' Data Type
Operations on strings
A std::string reference
Initializers
Iterators
Operators
Member functions
The IO-stream Library
Special header files
The foundation: the class `ios_base'
Interfacing `streambuf' objects: the class `ios'
Condition states
Formatting output and input
Output
Basic output: the class `ostream'
Output to files: the class `ofstream'
Output to memory: the class `ostringstream'
Input
Basic input: the class `istream'
Input from files: the class `ifstream'
Input from memory: the class `istringstream'
Copying streams
Coupling streams
Advanced topics
Redirecting streams
Reading AND Writing streams
Classes
The constructor
A first application
Constructors: with and without arguments
Objects inside objects: composition
Composition and const objects: const member initializers
Composition and reference objects: reference member initializers
Data member initializers (C++11, 4.7)
Delegating constructors (C++11, 4.7)
Uniform initialization (C++11)
Defaulted and deleted class members (C++11)
Const member functions and const objects
Anonymous objects
The keyword `inline'
Defining members inline
When to use inline functions
Local classes: classes inside functions
The keyword `mutable'
Header file organization
Using namespaces in header files
Sizeof applied to class data members (C++11)
Static Data And Functions
Static data
Private static data
Public static data
Initializing static const data
Generalized constant expressions (C++11)
Static member functions
Calling conventions
Classes And Memory Allocation
Operators `new' and `delete'
Allocating arrays
Deleting arrays
Enlarging arrays
Managing `raw' memory
The `placement new' operator
The destructor
Object pointers revisited
The function set_new_handler()
The assignment operator
Overloading the assignment operator
The `this' pointer
Sequential assignments and this
The copy constructor: initialization vs. assignment
Revising the assignment operator
Swapping
Moving data (C++11)
The move constructor (dynamic data) (C++11)
The move constructor (composition) (C++11)
Move-assignment (C++11)
Revising the assignment operator (part II)
Moving and the destructor (C++11)
Move-only classes (C++11)
Default move constructors and assignment operators (C++11)
Moving: implications for class design (C++11)
Copy Elision and Return Value Optimization
Plain Old Data (C++11)
Conclusion
Exceptions
Exception syntax
An example using exceptions
Anachronisms: `setjmp' and `longjmp'
Exceptions: the preferred alternative
Throwing exceptions
The empty `throw' statement
The try block
Catching exceptions
The default catcher
Declaring exception throwers
Iostreams and exceptions
Standard Exceptions
Exception guarantees
The basic guarantee
The strong guarantee
The nothrow guarantee
Function try blocks
Exceptions in constructors and destructors
More Operator Overloading
Overloading `operator[]()'
Overloading the insertion and extraction operators
Conversion operators
The keyword `explicit'
Explicit conversion operators (C++11)
Overloading the increment and decrement operators
Overloading binary operators
Overloading `operator new(size_t)'
Overloading `operator delete(void *)'
Operators `new[]' and `delete[]'
Overloading `new[]'
Overloading `delete[]'
`new[]', `delete[]' and exceptions
Function Objects
Constructing manipulators
The case of [io]fstream::open()
User-defined literals (C++11, 4.7)
Overloadable operators
Abstract Containers
Notations used in this chapter
The `pair' container
Sequential Containers
The `vector' container
The `list' container
The `queue' container
The `priority_queue' container
The `deque' container
The `map' container
The `multimap' container
The `set' container
The `multiset' container
The `stack' container
Unordered containers (`hash tables') (C++11)
Regular Expressions (C++11, ?)
The `complex' container
Unrestricted Unions (C++11)
Inheritance
Related types
Inheritance depth: desirable?
Access rights: public, private, protected
Public, protected and private derivation
Promoting access rights
The constructor of a derived class
Move construction (C++11)
Move assignment (C++11)
Inheriting constructors (C++11, ?)
The destructor of a derived class
Redefining member functions
i/ostream::init
Multiple inheritance
Conversions between base classes and derived classes
Conversions with object assignments
Conversions with pointer assignments
Using non-default constructors with new[]
Polymorphism
Virtual functions
Virtual destructors
Pure virtual functions
Implementing pure virtual functions
Explicit virtual overrides (C++11, 4.7)
Virtual functions and multiple inheritance
Ambiguity in multiple inheritance
Virtual base classes
When virtual derivation is not appropriate
Run-time type identification
The dynamic_cast operator
The `typeid' operator
Inheritance: when to use to achieve what?
The `streambuf' class
Protected `streambuf' members
The class `filebuf'
A polymorphic exception class
How polymorphism is implemented
Undefined reference to vtable ...
Virtual constructors
Friends
Friend functions
Extended friend declarations (C++11, 4.7)
Classes Having Pointers To Members
Pointers to members: an example
Defining pointers to members
Using pointers to members
Pointers to static members
Pointer sizes
Nested Classes
Defining nested class members
Declaring nested classes
Accessing private members in nested classes
Nesting enumerations
Empty enumerations
Revisiting virtual constructors
The Standard Template Library
Predefined function objects
Arithmetic function objects
Relational function objects
Logical function objects
Function adaptors
Iterators
Insert iterators
Iterators for `istream' objects
Iterators for `ostream' objects
The class 'unique_ptr' (C++11)
Defining `unique_ptr' objects (C++11)
Creating a plain `unique_ptr' (C++11)
Moving another `unique_ptr' (C++11)
Pointing to a newly allocated object (C++11)
Operators and members (C++11)
Using `unique_ptr' objects for arrays (C++11)
The legacy class 'auto_ptr' (deprecated)
The class 'shared_ptr' (C++11)
Defining `shared_ptr' objects (C++11)
Creating a plain `shared_ptr' (C++11)
Pointing to a newly allocated object (C++11)
Operators and members (C++11)
Casting shared pointers (C++11)
Using `shared_ptr' objects for arrays (C++11)
Classes having pointer data members (C++11)
Multi Threading (C++11)
The class 'std::thread' (C++11)
Synchronization (mutexes) (C++11)
Event handling (condition variables) (C++11)
Lambda functions (C++11)
Randomization and Statistical Distributions (C++11)
Random Number Generators (C++11)
Statistical distributions (C++11)
The STL Generic Algorithms
The Generic Algorithms
accumulate
adjacent_difference
adjacent_find
binary_search
copy
copy_backward
count
count_if
equal
equal_range
fill
fill_n
find
find_end
find_first_of
find_if
for_each
generate
generate_n
includes
inner_product
inplace_merge
iter_swap
lexicographical_compare
lower_bound
max
max_element
merge
min
min_element
mismatch
next_permutation
nth_element
partial_sort
partial_sort_copy
partial_sum
partition
prev_permutation
random_shuffle
remove
remove_copy
remove_copy_if
remove_if
replace
replace_copy
replace_copy_if
replace_if
reverse
reverse_copy
rotate
rotate_copy
search
search_n
set_difference
set_intersection
set_symmetric_difference
set_union
sort
stable_partition
stable_sort
swap
swap_ranges
transform
unique
unique_copy
upper_bound
Heap algorithms
STL: More function adaptors
Member function adaptors
Adaptable functions
Function Templates
Defining function templates
Considerations regarding template parameters
Late-specified return type (C++11)
Passing arguments by reference (reference wrappers) (C++11)
Using Local and unnamed types as template arguments (C++11)
Template parameter deduction
Lvalue transformations
Qualification transformations
Transformation to a base class
The template parameter deduction algorithm
Template type contractions
Declaring function templates
Instantiation declarations
Instantiating function templates
Instantiations: no `code bloat'
Using explicit template types
Overloading function templates
An example using overloaded function templates
Ambiguities when overloading function templates
Declaring overloaded function templates
Specializing templates for deviating types
Avoiding too many specializations
Declaring specializations
Complications when using the insertion operator
Static assertions (C++11)
Numeric limits
Polymorphous wrappers for function objects (C++11)
Compiling template definitions and instantiations
The function selection mechanism
Determining the template type parameters
SFINAE: Substitution Failure Is Not An Error
Summary of the template declaration syntax
Class Templates
Defining class templates
Constructing the circular queue: CirQue
Non-type parameters
Member templates
CirQue's constructors and member functions
Using CirQue objects
Default class template parameters
Declaring class templates
Preventing template instantiations (C++11)
Static data members
Extended use of the keyword `typename'
Specializing class templates for deviating types
Example of a class specialization
Partial specializations
Intermezzo: some simple matrix algebraic concepts
The Matrix class template
The MatrixRow partial specialization
The MatrixColumn partial specialization
The 1x1 matrix: avoid ambiguity
Variadic templates (C++11)
Defining and using variadic templates (C++11)
Perfect forwarding (C++11)
The unpack operator (C++11)
Non-type variadic templates (C++11)
Tuples (C++11)
Computing the return type of function objects (C++11)
Instantiating class templates
Processing class templates and instantiations
Declaring friends
Non-templates used as friends in templates
Templates instantiated for specific types as friends
Unbound templates as friends
Extended friend declarations (C++11, 4.7)
Class template derivation
Deriving ordinary classes from class templates
Deriving class templates from class templates
Deriving class templates from ordinary classes
Class templates and nesting
Constructing iterators
Implementing a `RandomAccessIterator'
Implementing a `reverse_iterator'
Advanced Template Use
Subtleties
Returning types nested under class templates
Type resolution for base class members
::template, .template and ->template
Template Meta Programming
Values according to templates
Selecting alternatives using templates
Templates: Iterations by Recursion
User-defined literals (C++11, 4.7)
Template template parameters
Policy classes - I
Policy classes - II: template template parameters
Structure by Policy
Template aliases (C++11, 4.7)
Trait classes
Distinguishing class from non-class types
Available type traits (C++11)
More conversions to class types
Types to types
An empty type
Type convertibility
Template TypeList processing
The length of a TypeList
Searching a TypeList
Selecting from a TypeList
Prefixing/Appending to a TypeList
Erasing from a TypeList
Using a TypeList
The Wrap and Multi class templates
The MultiBase class template
Support templates
Using Multi
Concrete Examples
Using file descriptors with `streambuf' classes
Classes for output operations
Classes for input operations
Fixed-sized field extraction from istream objects
The `fork' system call
A basic Fork class
Parents and Children
Redirection revisited
The `Daemon' program
The class `Pipe'
The class `ParentSlurp'
Communicating with multiple children
Function objects performing bitwise operations
A text to anything converter
Adding binary operators to classes
Binary operators allowing promotions
Range-based for-loops and pointer-ranges (C++11)
Distinguishing lvalues from rvalues with operator[]()
Implementing a `reverse_iterator'
Using `bisonc++' and `flex'
Using `flex' to create a scanner
Using `bisonc++' and `flex'
Using polymorphic semantic values with Bisonc++
Using unrestricted unions as semantic values (C++11)