Advanced C++ Training Course

Duration: 5 Days
Course code: SS-CPP-002

  • Application Developers
  • Programmers
  • System Designers

A Familiarity with C++


Advanced C++ Training course offers a comprehensive coverage of the advanced features of the C++ language.

The course starts with basic OO concepts, and then a quick introduction to the language. The language is presented, not as an extension of C, but as a demonstration of how object-oriented development promotes a new, productive way of thinking.

Other topics covered include Templates, Standard Template Library (STL) and Exceptions. The course also covers some advanced Object-Oriented design techniques in C++ such as Design Heuristics, Design by Contract, Interfaced-based programming, Composition and Delegation Patterns, Memory Management and Smart Pointers, Subtyping, Design for efficiency and Meta programming in C++.


The course includes a complete overview of the new features in C++11 and C++14

Our goal is to transfer as much knowledge as possible from the classroom to the workplace. Advanced C++ Training course has been carefully designed to ease a C++ programmer into new and advanced language features and advanced Object-Oriented design concepts in C++ with the use of lots of hands-on exercises. At the end of this course, students should:

  • Apply advanced concepts of OO designs
  • Be able to write and maintain C++ programs
  • Write robust, maintainable, elegant and efficient C++ code
  • Be able to deploy good C++ programming practices
  • Be able to use the advanced features of the C++ programming language
  • Be able to implement advanced Object-Oriented techniques in C++ to realize efficient and flexible applications
  • Leave with skills needed to develop industrial C++ applications

Outline for Advanced C++ Programming Training Course

Language History and C++11/14

  • History of C++
  • Versions
  • New in TR1
  • New in C++11
  • New in C++14

Language Review and Best Practice: Part I

  • Object-Oriented Programming
  • Constructors and Destructors
  • new and delete

Basic Inheritance

  • Interface vs. Implementation
  • Type Inheritance
  • Implementation Inheritance
  • Proper Use of C++11 final and override
  • Virtual Destructors: When and Why?
  • Inheritance Guidelines

Correct Use of Well Known Language Features

  • Pointers vs. References vs. Value
  • Proper Use of const
  • Proper Use of Inline Functions
  • Proper Use of static
  • Proper Use of Default Parameters
  • Proper Use of friend
  • Proper Use of namespace
  • The C++ Way to Cast
  • Proper Use of friend
  • Proper Use of Operator Overloading
  • Copy Constructor: Why/When?
  • Assignment Operator: Why/When?
  • The Law of The Big Three


  • Lessons from Traditional Error Handling
  • Object-Oriented Error Handling
  • throw, try and catch
  • Design of Exception Hierarchies
  • Proper use of Rethrow
  • using unexpected
  • Exception Pitfalls
  • Exception Guidelines


  • Template Classes Definition
  • Template Classes Implementation
  • Parametrized Classes
  • Templates and Non-Type Parameters
  • Template Guidelines
  • Templates and Plain Functions
  • C++ Template Function

Standard Template Library (STL)

  • STL String
  • STL Components
  • Sequence Containers
  • Use of Iterators in STL
  • Example of Algorithms
  • Initialization of Containers
  • Performance Profiles of Sequence Containers

STL Algorithms

  • STL vs Boost
  • Parameterization of Algorithms
  • Using Functions
  • Using Function Objects
  • Using Lambda Expressions
  • Library of Selected Algorithms
  • Contributing Algorithms

STL Associative Containers

  • Set
  • Multiset
  • Map
  • Multimaps

STL Functors, Allocators and More

  • Standard Exception
  • Functors
  • Library Provided Function Objects
  • Using STL Function Objects and Binders
  • Negators
  • Allocators
  • Complex Number
  • Smart Pointers
  • auto_ptr (Deprecated)
  • shared_ptr (Deprecated)
  • unique_ptr (Deprecated)
  • weak_ptr (Deprecated)

Efficiency: Temporary Objects

  • Temporary Objects: The Problem
  • Various Techniques to Avoid Temporaries
  • STL String: How to Avoid Creation of Temporaries
  • C++11: Move Semantics
  • Miscellaneous Techniques to Avoid Temporaries

Memory Management

  • How Does C++ Use Memory?
  • Basic Guidelines
  • Implementation of Singletons in C++
  • Efficient Use of Smart Pointers
  • Overloading new and delete

Memory Management

  • How Does C++ Use Memory?
  • Basic Guidelines
  • Implementation of Singletons in C++
  • Efficient Use of Smart Pointers
  • Overloading new and delete
  • The Importance of Data Layout
  • Hot vs. Cold Memory

Miscellaneous Efficiency Techniques

  • Design Concerns
  • Flexibility vs Performance
  • Lazy Evaluation
  • Eager Evaluation
  • Copy on Write Techniques
  • Data Layout Revisited
  • Modern Hardware and Cache Pipelines
  • The Effect of Data Structures and Algorithms
  • Postcondition and C++
  • Efficiency Profiles of Libraries
  • STL and Performance
  • Latency
  • Cost and Benefits of Threads
  • Asynchronous Programming
  • Futures


  • Concept of Delegation
  • Delegation in C++
  • Simple Delegation
  • Static Delegation
  • Superclass Delegation
  • Subclass Delegation
  • Issues With Subclass Delegation in C++
  • Object Delegation
  • Strategy Pattern
  • C++ and Strategy
  • State Pattern
  • C++ and State
  • Design of Composite
  • Composite and Delegation
  • Other Delegation Patterns


  • What is Coupling?
  • Kinds of Coupling
  • Identity Coupling
  • Identity Coupling: Object Lifetimes
  • Change of Identity
  • Type Coupling
  • Implementation Coupling
  • Interfaces and Implementations
  • Decoupling by Example

Advanced Inheritance

  • Multiple Inheritance of Interfaces
  • Multiple Inheritance of Implementation
  • Shared Properties
  • Resolving Ambiguity
  • Virtual Inheritance
  • Multi Methods
  • Double Dispatch
  • Use of RTTI
  • Rules and Guidelines
  • Inheritance of Baseclass Methods
  • Change of Methods
  • Contracts and Inheritance
  • Contracts and Subtyping
  • Variations of Method Arguments
  • Rules for Method Arguments
  • Rules for Changing Return Types
  • Cancellations of Methods

Design Heuristics

  • Object-Oriented Design Guidelines
  • Reflecting Client's View
  • Polling
  • Express Interfaces Through Objects
  • Value Objects
  • Class Invariants
  • Abstract Base Classes
  • Classes and Interfaces
  • Design Interfaces Between Base and Derived Classes
  • Classes Cohesiveness
  • Interface Bloat
  • Encapsulation Leakage

Comments are closed.