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 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 updated May 2014

Course Contents

• The canonical class definition
• Why const is important
• Raw and smart pointers
• Robust C++ code: guidelines

• Overloading index operators [] and ()
• The assignment operator and memory management
• Overloading the ostream operator <<
• Functors and function objects
• Comparing functors with function pointers

• 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

• Multiple parameters
• Nested template class
• Inheritance and composition
• Compile-time and fixed-sized array classes

• Default parameter values
• Template template parameters
• Some templated design patterns
• Template specialization; partial specialisation

• Traits classes
• Services and policy-based design
• 'Provides' and 'requires' interfaces
• Implementing policies in C++

• Creating pattern languages
• Creating networks of inter-related patterns
• Using GOF patterns in larger architectures
• Finding the right patterns
• Contracts and where clauses

• An introduction to generic programming
• Comparing OOP with GP
• Designing components in GP framework
• 'Provides' and 'requires' interfaces

• Traits and their applications
• Policy classes
• Combining policies and traits
• Test Case: a policy-based templated Command and Proxy patterns
• Examples

• 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

• Sequence Containers
• Vector
• Deque
• List

• Multisets (Bags)
• Sets
• Set_like Operations on Sorted Structures
• Multimaps
• Maps

• 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

• Overview of STL Algorithms
• Algorithm Categories
• Algorithms with Function Parameters
• Non-mutating Sequence Algorithms
• Mutating Sequence Algorithms
• Sorting and searching

• 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

• 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

• 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

• 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

• Overview and application areas
• The Statistical Accumulators Library
• Examples and test cases

• Network and low-level I/O
• Proactor design patterns
• Strands
• Custom memory allocation

• TCP, UDP, ICMP
• Socket I/O streams
• SSL support
• Serial ports

• Shared memory
• Memory-mapped files
• Semaphores and mutexes
• File locking
• Message queues

• Hierarchical (composite, nested) states
• Orthogonal states
• Transitions and Guards
• Event delay

Module 7: Multi-threaded and Parallel Programming

Boost Thread

• 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

• Fork-join (master/slave) model
• Shared and private data
• Thread synchronisation

• Mutual exclusion (mutex) and condition variables
• Critical sections
• Memory synchronisation and fences
• Barriers

• Sequential consistency
• Removing data dependencies
• Race conditions
• Deadlock and livelock

• Free thread functors
• Thread classes
• Non-member functions
• Status of Boost Thread

• Mutex concepts
• Lock mechanism and lock types
• Condition variables
• Barriers
• Futures

• Thread local storage
• Emulations
• Conformance and Extension

• Compiler directives
• Library routines
• Environment variables

• Writing the serial program
• Determining parallel code
• Adding OpenMP directives
• Debugging and performance measurement

• Shared and private
• Lastprivate, firstprivate
• Default and nowait clause

• Barrier
• Ordered
• Critical and Atomic
• Locks, Master construct

• Loop construct
• Sections and section
• Single construct
• Combined parallel work-sharing constructs
• Other Clauses
• Reduction clause
• Copyin clause
• Copyprivate clause
• Ordered clause

• Setting environment variables' values
• Library functions for thread information
• Scheduling functions
• Lock functions
• Timing functions

• Overview of Unified Modelling Language (UML)
• Class diagrams
• Component diagrams
• Sequence diagrams

• 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

• 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

• 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

• Choice of programming models
• Complexity Analysis and data structures
• Which STL and boost libraries to use
• Design patterns

• Classifying and discovering performance bottlenecks
• Virtual versus non-virtual functions
• Preventing unnecessary object creation
• Exceptional handling

• Templates versus inheritance
• Using the appropriate data structures from STL
• Loop optimizing techniques
• Loop fission, fusion, unrolling and tiling

• Core language usability enhancements
• Core language functionality improvements
• C++ standard library changes

• Abstract data types and algorithms
• Taxonomy of data structures
• Mathematical tools for algorithm analysis
• Linear and nonlinear data types
• Design strategies

• Vectors, matrices and arrays
• Sets, stack and queues
• Linked lists

• Computational and asymptotic complexity
• Big-O notations
• Other measures of complexity
• Potential problems
• NP-completeness

Recursion

• 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 

• Hash function and hash table
• Categories of hash function
• Creating custom hash
• Applications

• Heap ADT
• Variants (Fibonacci, skew, priority queue, etc.)
• Heap and computational efficiency
• Boost Heap versus STL heap

• Hashed associative containers
• Complexity analysis
• Applications
• Integration with STL and other Boost libraries
• Custom Types
• Controlling the number of buckets

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


Click here to register.


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




Share this page:

Tweet