-   Forums
     -   Articles and Whitepapers
     -   Downloads
     -   Courses and Events
     -   Course Registration
     -   Distance learning
     -   Courses for Universities
     -   Books
     -   Audios and Demos
     -   Testimonials

Share this page:  Tweet

Distance Learning - Advanced C++ - Programming Models, boost and Parallel Computation - (code DL-CPP)

The goal of this hands-on distance learning course is to learn the most advanced features of object-oriented and generic programming in C++, the STL and Boost libraries and modern software design methods. We have developed this course for those professionals working in business, engineering and other areas who are involved in software development. The ten modules in the course represent state of the start developments in C++.

Click here for a video overview of this course.

Subjects Covered

We discuss the following major categories:

  • Quick review of C++.
  • Generic programming and policy-based design in C++.
  • The Standard Template (STL) in great detail (including 70 major algorithms).
  • More than 50 major Boost C++ libraries.
  • Multithreading (Boost Thread and OpenMP).
  • Design and implementation of complex component software systems.

The details of each category are described below. The approach in this course is to take a step-by-step approach by motivating each topic, first in simple terms in combination with clear examples/exercises and then progressing to more advanced concepts and hands-on examples.

Course Benefits

This course is self-contained and we deliver all the slides, videos, exercises, code and books that you use to use C++ and libraries to build robust and efficient applications:

  • Unique combination of design, STL, Boost and C++ to create robust and efficient applications.
  • A unified, modern and comprehensive course for professional developers.
  • Interaction with, and feedback from your mentor.
  • Full documentation and source code.
  • Student exercises, project and certificate.
  • Lifelong access to the materials (including updates).

How does Distance Learning work?

The current distance learning formula is based on our other distance learning programs. The main steps in the process are:

  1. The student registers for the Advanced C++ distance learning course by sending us a signed registration form (which can be printed from our website) after which we will send an invoice. Once we have received the full payment in our bank account we will enable you as a user on the Advanced C++ distance learing forum.
  2. We send you 4 textbooks on C++, as well as full source code, manuscripts and exercises (per module) in the post.
  3. For each module, we have a special forum section where you can find screen capture/audios, videos, user area and ongoing developments
  4. We include a step-by-step account on how to learn each module, and how to test your knowledge after you have finished the module (including sending your finished exercises to the mentor and other feedback)
  5. Optionally, it is possible to do an examination and do a project. This is included in the price of the course.
  6. You can ask questions and send your code to the mentor at any time for review.
  7. On successful completion, you will be presented with a certificate.

The books provided with this course are:
  • The C++ Standard Library: A Tutorial and Reference (2nd Edition) Nicolai M. Josuttis
  • Using OpenMP, by Barbara Chapman
  • Introduction to the Boost C++ Libraries - Volume I, by Robert Demming & Daniel J. Duffy
  • Introduction to the Boost C++ Libraries - Volume II, by Robert Demming & Daniel J. Duffy

Typically, the duration of the course is one year. This estimate is based on the fact that most students have a full-time job and will do the course in their free time.

Course Originator
This course was originated, developed and is supported by Daniel J. Duffy. He has a BA degree in Mathematics as well as MSc and PhD in Numerical Analysis (the numerical solution of partial differential equations). He has many years industrial and business experience and is author of several books on numerical methods, C++ and applications to engineering and computational finance.

                                                                                                   Course updated May 2014

Course Contents

Module 1: Quick Review of C++ Essentials

General Considerations
  • The canonical class definition
  • Why const is important
  • Raw and smart pointers
  • Robust C++ code: guidelines
Advanced Overloading
  • Overloading index operators [] and ()
  • The assignment operator and memory management
  • Overloading the ostream operator <<
  • Functors and function objects
  • Comparing functors with function pointers
Simple Inheritance
  • Inheritance and ISA Relationship
  • Specialisation Scenarios
  • Inheritance and Object Creation
  • Using Base Class Constructors
  • Accessibility of Base Members
  • Overriding Functions
  • Pointers to the Base Class
  • Function Visibility
  • Polymorphism
  • Defining an Interface
  • Abstract Base Classes
  • Virtual Destructors
  • Operator Overloading and Inheritance

Module 2: Generic Programming and Policy-based Design

Programming with Templates I
  • Multiple parameters
  • Nested template class
  • Inheritance and composition
  • Compile-time and fixed-sized array classes
Programming with Templates II
  • Default parameter values
  • Template template parameters
  • Some templated design patterns
  • Template specialization; partial specialisation
Templated Software Components
  • Traits classes
  • Services and policy-based design
  • 'Provides' and 'requires' interfaces
  • Implementing policies in C++
Advanced GOF: Combining Components into larger Components
  • Creating pattern languages
  • Creating networks of inter-related patterns
  • Using GOF patterns in larger architectures
  • Finding the right patterns
  • Contracts and where clauses
Generic Patterns and Generic Programming
  • An introduction to generic programming
  • Comparing OOP with GP
  • Designing components in GP framework
  • 'Provides' and 'requires' interfaces
The Design of Generic Components
  • Traits and their applications
  • Policy classes
  • Combining policies and traits
  • Test Case: a policy-based templated Command and Proxy patterns
  • Examples

Module 3: Standard Template Library (STL)

Overview of Standard Template Library (STL)
  • What is STL?
  • STL Components
  • Containers
  • Main Container Types
  • Algorithms
  • Main Algorithm Categories
  • Set-like Operations
  • Iterators
  • Function Objects
  • Adaptors
  • Allocators
  • Strengths and Limitations of STL
  • Student Prerequisite Knowledge
STL Containers
  • Sequence Containers
  • Vector
  • Deque
  • List
Sorted Associative Containers
  • Multisets (Bags)
  • Sets
  • Set_like Operations on Sorted Structures
  • Multimaps
  • Maps
Iterators in STL
  • What is an Iterator?
  • Iterator Categories
  • Iterator functions
  • Iterator functions: Input Iterators
  • Output Iterator Types
  • Forward Iterators
  • Bi-directional Iterators
  • Random Access Iterators
  • Qualifying Iterators: Mutable and Constant Iterators
Algorithms in STL
  • Overview of STL Algorithms
  • Algorithm Categories
  • Algorithms with Function Parameters
  • Non-mutating Sequence Algorithms
  • Mutating Sequence Algorithms
  • Sorting and searching

Module 4: Boost Containers, Data Structures and Higher-Order Programming

  • Creating n-dimensional data structures
  • Performance issues compared to STL
  • Slicing and views
  • Resize, reshape and storage
  • Multi-index and sub-object searching
  • Modelling pairs of iterators
  • Using ranges with generic algorithms and STL containers
  • Raising the abstraction level
  • Using metafunctions
  • Modelling n-tuples (pair is a 2-tuple)
  • Using tuples as function arguments and return types
  • Accessing the elements of a tuple
  • Advantages and applications of tuples
  • Creating discriminated unions with heterogeneous types
  • Manipulating several distinct types in a uniform manner
  • Type-safe visitation
  • Avoiding type-switching for variant data
  • Value-based variant types
  • Discriminated types
  • Typesafe storage and retrieval Applications of Any
Multi-Index Containers
  • Bidirectional maps
  • Sets with several iteration orders
  • Emulation of standard containers
  • MRU lists
  • Category: Function Objects and Higher-Order Programming
  • Generalising and improving the STL Bind
  • Uniform syntax for functors, (member) function pointers
  • Functional composition and nested binders
  • Bind as used in Boost.Function
  • Generalised callback mechanisms
  • Storage and invocation of functors, (member) function pointers
  • Useful in notification patterns (Observer, Signals and Slots)
  • Example: separating GUIs from business logic
Signals and Slots
  • Implementation of Observer (Publisher-Subscriber) pattern
  • Event management with minimal inter-object dependencies
  • Signals == Subject, Slots == Subscriber
  • Application to Mediator and Observer patterns
  • Unnamed functions
  • Useful for STL algorithms
  • Avoiding creation of many small function objects
  • Less code: write function at location where it is needed
  • Lambda function in C++ 11

Module 5: Boost I/O and other Utilities

  • Portable manipulation of paths, directories and files
  • Defining functionality as in scripting languages
  • Platform portability
  • Saving arbitrary data to an archive (e.g. XML)
  • Restoring data from an archive
  • Versioning
  • Regular expressions and pattern matching
  • Processing large and inexact strings
  • Emulating functionality as in Perl, awk, sed
  • Functional, recursive descent parser generator framework
  • Command-line parsers
  • Specifying grammar rules in C++ (EBNF syntax)
  • Performance issues
  • Separate character sequences into tokens
  • Finding data in delimited text streams
  • User-defined delimiters
Time Series and Forecasting
  • Linear and multiple regression
  • Smoothing
  • Exponential smoothing
  • Multiplicative model
Boost Accumulator Library
  • Overview and application areas
  • The Statistical Accumulators Library
  • Examples and test cases
Module 6: Boost Interprocess and Network Communication

Asynchronous Communication
  • Network and low-level I/O
  • Proactor design patterns
  • Strands
  • Custom memory allocation
  • Socket I/O streams
  • SSL support
  • Serial ports
  • Shared memory
  • Memory-mapped files
  • Semaphores and mutexes
  • File locking
  • Message queues
UML Statecharts in Boost
  • Hierarchical (composite, nested) states
  • Orthogonal states
  • Transitions and Guards
  • Event delay

Module 7: Multi-threaded and Parallel Programming

Boost Thread

Memory Systems
  • Shared memory parallel computers (SMPs)
  • Shared and cache memory
  • Shared memory consistency models
  • Distributed memory and shared distributed memory
  • What is a thread?
  • Thread attributes
  • Thread execution lifecycle
  • User threads and kernel threads
Data Access in Threads
  • Fork-join (master/slave) model
  • Shared and private data
  • Thread synchronisation
Synchronisation in Detail
  • Mutual exclusion (mutex) and condition variables
  • Critical sections
  • Memory synchronisation and fences
  • Barriers
  • Sequential consistency
  • Removing data dependencies
  • Race conditions
  • Deadlock and livelock
Boost Threads
  • Free thread functors
  • Thread classes
  • Non-member functions
  • Status of Boost Thread
  • Mutex concepts
  • Lock mechanism and lock types
  • Condition variables
  • Barriers
  • Futures
Other Topics
  • Thread local storage
  • Emulations
  • Conformance and Extension

Module 8: OpenMP, an Introduction

  • Compiler directives
  • Library routines
  • Environment variables
My First OpenMP Program
  • Writing the serial program
  • Determining parallel code
  • Adding OpenMP directives
  • Debugging and performance measurement
Data Clauses in OpenMP
  • Shared and private
  • Lastprivate, firstprivate
  • Default and nowait clause
OpenMP Synchronisation Constructs
  • Barrier
  • Ordered
  • Critical and Atomic
  • Locks, Master construct
Work Sharing in OpenMP
  • Loop construct
  • Sections and section
  • Single construct
  • Combined parallel work-sharing constructs
  • Other Clauses
  • Reduction clause
  • Copyin clause
  • Copyprivate clause
  • Ordered clause
Configuration and Run-Time Information
  • Setting environment variables' values
  • Library functions for thread information
  • Scheduling functions
  • Lock functions
  • Timing functions

Module 9: Applications: Design and Implementation

Structural Modelling, I
  • Overview of Unified Modelling Language (UML)
  • Class diagrams
  • Component diagrams
  • Sequence diagrams
Structural Modelling, II
  • Semantic modelling
  • Generalisation/Specialisation (Inheritance)
  • Aggregation and Composition
  • Association and association class

Whole-Part Pattern

  • Modelling complex structured objects
  • Whole-Part types
  • Checklist: which type to use
  • The steps in implementing Whole-Part object
  • Applications for Whole-Part

Detailed Software Requirements for Components

  • Throwaway, non-throwaway and production software
  • What are the top software requirements?
  • Functional and non-Functional requirements (FRs and NFRs)
  • How FRs and NFRs affect component design
Combining Component and Object Technologies
  • Comparing Component and Object Design
  • The differences between OOD and COD
  • Combining components and objects
  • Assemblies and namespaces
  • Developing components from objects
  • Component loading and the object instantiation process
Using Components and Objects for GOF Patterns
  • When to use interfaces and when to use abstract classes
  • Using classes and objects in combination with components
  • Stateless and Stateful GOF patterns
  • Delegation and Composition
Designing C++ Applications
  • Choice of programming models
  • Complexity Analysis and data structures
  • Which STL and boost libraries to use
  • Design patterns
Performance of C++ I
  • Classifying and discovering performance bottlenecks
  • Virtual versus non-virtual functions
  • Preventing unnecessary object creation
  • Exceptional handling
Performance of C++ II
  • Templates versus inheritance
  • Using the appropriate data structures from STL
  • Loop optimizing techniques
  • Loop fission, fusion, unrolling and tiling
C++ 11 Update (contents similar to Wiki entry C++ 11)
  • Core language usability enhancements
  • Core language functionality improvements
  • C++ standard library changes
Module 10: Linear and Nonlinear Data Structures

  • Abstract data types and algorithms
  • Taxonomy of data structures
  • Mathematical tools for algorithm analysis
  • Linear and nonlinear data types
  • Design strategies
Review of Fundamental Data Structures
  • Vectors, matrices and arrays
  • Sets, stack and queues
  • Linked lists
Complexity Analysis
  • Computational and asymptotic complexity
  • Big-O notations
  • Other measures of complexity
  • Potential problems
  • NP-completeness


  • Basic concepts
  • Function calls and recursive implementation
  • Tail, nontail and nested recursion
  • Backtracking

Binary Trees

  • Mathematical properties
  • Complete and full binary trees
  • Computed the depth of a binary tree
  • 2-trees

Introduction to Graph Theory

  • Directed and Undirected Graphs
  • Properties of Graphs and graph
  • Paths and Connectivity 
  • Special Types of Graphs

Graph Structure and Algorithms

  • Graph data structures and operations on graphs
  • Minimum spanning tree (MST) problems
  • Depth-first and Breadth-first searches in graphs
  • Shortest path problems
  • Connected components 
Boost Functional Hash
  • Hash function and hash table
  • Categories of hash function
  • Creating custom hash
  • Applications
Boost Heap
  • Heap ADT
  • Variants (Fibonacci, skew, priority queue, etc.)
  • Heap and computational efficiency
  • Boost Heap versus STL heap
Boost Unordered
  • Hashed associative containers
  • Complexity analysis
  • Applications
  • Integration with STL and other Boost libraries
  • Custom Types
  • Controlling the number of buckets

Boost Bimap
  • What is a bidirectional map?
  • The three views of a bimap
  • Integration with STL
  • Implementing UML association class

  • Prerequisites

    A reasonably good knowledge of the C++ syntax. We have a review module in the course to bring those students who need to refresh their C++ knowledge.

    Who should attend?

    For all developers and designers who use C++ as development language.

    Duration, price, date, locations and registration

    Course duration: Distance learning.
    You study in your own pace. Under normal circumstances, this should take you between 1 and 1.5 years to complete.
    Dates and location: (click on dates to print registration form)

    Date(s) Location Price Language
    Any time Distance Learning € 3245.-- ex. VAT
    € 3926.45 inc. 21% VAT

    Click here to register.

    This distance learning course can start at any moment. We offer company-wide discount schemes for groups.

    Share this page:  Tweet