Program structure

• "Hello World!"
• The build process
• Object files
• Linking Activities

Stream I/O

• C++ stream I/O objects
• Stream modifiers

The C++ object model

• Objects and types
• Brace initialisation
• Object visibility scope
• Object lifetime

Constants

• Literals
• Compile-time constant expressions
• Enum classes

Pointers

• Dynamic objects
• The value of an ‘empty’ pointer
• Pointers and const

Hardware manipulation

• Memory-mapped registers are accessed via pointers
• volatile objects
• Bitwise Operators
• General Purpose Input / Output (GPIO)

Structures

• User-defined types
• Packing
• Performance implications of packing

Arrays

• Containers
• The iterator model
• Range-for statement
• Applying algorithms to arrays – filling and sorting

Functions

• The 'One Declaration Rule'
• How function arguments are passed
• The overheads of pass-by-value
• Pass-by-reference
• std::tuple represents a general n-tuple
• Function overloading
• Function inlining

Structuring code

• Separating Interface and Implementation
• Compilation Dependencies
• Using the __cplusplus macro

Namespaces

• Defining functions within a namespace
• Ambiguity when accessing namespace members

Principles of Object Oriented Design

• Coupling
• Encapsulation
• Cohesion
• The Single Responsibility Principle
• Abstraction

User-defined types

• Creating new types
• Access specifiers
• 'this' pointer

Initialising objects

• Non-Static Data Member Initializers (NSDMIs)
• The compiler-supplied default constructor
• The class destructor

Objects and functions

• Pass-by-value
• Explicit constructors
• Disabling pass-by-value
• Disabling copying
• Return Value Optimisation (RVO)
• 'Copy elision'

Static

• The static storage specifier
• Static member variables
• Static member functions

Object-based I/O

• An Object-Oriented approach to I/O
• Using a struct for I/O device access
• Nesting a structure overlay in a class

Operator overloading

• Problem domain types
• Overloading the stream operator
• Conversions to other user-defined types

Building composite objects

• Composite aggregation
• Overriding default initialisers
• The composite object on the stack...

Connecting objects

• Connected objects form a system
• Forming the Association (Client-Server)
• Bi-directional associations…
• Friend functions
• Forward references to namespace elements

Creating Substitutable Objects

• Specialisation
• Inheritance
• Overriding base class behaviour
• The 'protected interface'
• The Liskov Substitution Principle
• Late binding (of polymorphic operations)
• Dynamic binding

Abstract Base Classes

• An abstract class
• Extending derived classes
• Safely accessing the extended interface

Realising Interfaces

• The Dependency Inversion Principle
• Provided and Required Interfaces
• The Interface Segregation Principle
• Cross-casting

Dynamic objects

• Memory model
• std::unique_ptr allows single ownership
• std::shared_ptr is reference-counted
• std::weak_ptr
• Resolving circular dependency issues

Dynamic containers

• Sequence containers
• std::vector is a dynamically-resizable array
• std::list is a doubly-linked list
• Key-value containers – std::pair
• Sorted containers
• Containers and memory allocation

Callable objects

• Function objects
• Lambdas
• Under the hood
• Using std::function for call-back
• Containers of callable objects

Initializer lists

• std::initializer_list
• initializer_list overload rules

Template functions

• Generic programming
• Function templates
• Overloading with template functions

Template classes

• Class templates
• Lazy instantiation
• Member Functions of Class Templates