Go to the Datasim Education BV homepage Datasim Education BV Datasim Education BV Datasim Education BV Datasim Education BV Datasim Education BV
Courses
Books
Downloads
Information request
Forum



Follow datasim on Twitter

Share this page

COURSE DETAILS
Advanced C++ Programming




Course Category: 
Course: 


Advanced C++ - Programming Models, Libraries 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 nine modules in the course represent state of the start developments in C++.


What do you learn?

  • Modern object-oriented and generic programming techniques
  • STL and boost libraries from A to Z
  • Multi-threaded and parallel programming in C++
  • Design techniques and creating applications

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
Polymorphism
  • 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


MultiArray
  • Creating n-dimensional data structures
  • Performance issues compared to STL
  • Slicing and views
  • Resize, reshape and storage
  • Multi-index and sub-object searching
Range
  • Modelling pairs of iterators
  • Using ranges with generic algorithms and STL containers
  • Raising the abstraction level
  • Using metafunctions
Tuple
  • 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
Variant
  • Creating discriminated unions with heterogeneous types
  • Manipulating several distinct types in a uniform manner
  • Type-safe visitation
  • Avoiding type-switching for variant data
Any
  • 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
Bind
  • Generalising and improving the STL Bind
  • Uniform syntax for functors, (member) function pointers
  • Functional composition and nested binders
  • Bind as used in Boost.Function
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
Lambda
  • Unnamed functions
  • Useful for STL algorithms
  • Avoiding creation of many small function objects
  • Less code: write function at location where it is needed

Module 5: Boost I/O and other Utilities

Filesystem
  • Portable manipulation of paths, directories and files
  • Defining functionality as in scripting languages
  • Platform portability
Serialisation
  • Saving arbitrary data to an archive (e.g. XML)
  • Restoring data from an archive
  • Versioning
Regex
  • Regular expressions and pattern matching
  • Processing large and inexact strings
  • Emulating functionality as in Perl, awk, sed
Spirit
  • Functional, recursive descent parser generator framework
  • Command-line parsers
  • Specifying grammar rules in C++ (EBNF syntax)
  • Performance issues
Tokenizer
  • Separate character sequences into tokens
  • Finding data in delimited text streams
  • User-defined delimiters

Module 6: Boost Interprocess and Network Communication

Asynchronous Communication
  • Network and low-level I/O
  • Proactor design patterns
  • Strands
  • Custom memory allocation
Networking
  • TCP, UDP, ICMP
  • Socket I/O streams
  • SSL support
  • Serial ports
Interprocess
  • 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
  • Threads and thread groups
  • Synchronisation (mutex, locks, barriers etc.)
  • Thread local storage
  • Date and time requirements
Message Passing Interface (MPI) in Boost
  • An Introduction to MPI
  • What is distributed computing?
  • Message passing metaphor
  • Fundamental MPI concepts
  • MPI library functions
MPI Core
  • Communicators Point-to-point communication
  • Collective communication
  • MPI data type
  • Separating form and content

Module 8: OpenMP, an Introduction


Overview
  • 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

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

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.

Course form

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 3 textbooks on C++, as well as 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. On successful completion, you will be presented with a certificate.


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.

Your mentor is Dr. Daniel J. Duffy

Duration, price, date, locations
Course duration 365 days
Price Euro 3245.-- ex. VAT
Euro 3926.45 inc. 21% VAT
Date and location Dates available on request

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

It is also possible to organize this course at your company premises (the in-company option). If you have any question, please contact our Datasim office.

Share this page

Contact and Profile
Registration form
Course Dates