Course Description

This comprehensive, five-day C++ Programming Advanced training course consists of three modules.

A preliminary module reviews topics, including inheritance, the ANSI C++ Standard Library, templates. I/O streams, and practical issues of C++ programming, such as reliability, testing, efficiency and interfacing to C. This material is covered as needed depending on the background of the students.

The second module covers more advanced topics. Advanced issues of inheritance and polymorphism are covered. Principles of effective class design, including the orthodox canonical form, use of composition, templates and interface inheritance. The course covers exception handling and runtime type information (RTTI). Multiple inheritance is covered, including the complications that are introduced by this powerful feature. Advanced applications of C++ concepts are studied, including smart pointers and reference counting.

The third module introduces the Standard Template Library (STL). The main components of data structures, algorithms and iterators are covered. Illustrations are provided of a number of important containers, such as vectors, stacks, queues, lists and sets. Extensive programming examples and exercises are provided. A number of progressively developed case studies are used to illustrate object oriented programming techniques and to give the student practical experience in putting together features of C++ learned in the course. A file is provided containing all the examples and laboratory exercises in the course.


Substantial C++ programming experience.


Who is this course for?

This training course is designed for experienced C++ programmers who wish to deepen their understanding of the language and learn advanced techniques.


Course content

Inheritance & Polymorphism
Inheritance Concept
Inheritance in C++
Protected Members
Base Class Initializer List
Member Initialization List
Order of Initialization
Inheritance vs. Composition
Summary – Inheritance
A Case for Polymorphism
Dynamic Binding
Pointer Conversion in Inheritance
Polymorphism Using Dynamic Binding
Virtual Function Specification
Invoking Virtual Functions
Virtual Destructors
Abstract Class Using Pure Virtual Function
Employee as an Abstract Class
Inheritance and Polymorphism
ANSI C++ Library
ANSI C++ Library
Hello ANSI C++
ANSI C++ String Class
General Purpose Functions
Function Templates
Template Parameters
Template Parameter Conversion
Function Template Problem
Generic Programming
General Purpose Classes
Class Templates
Array Class Implementation (array.h)
Using the Array Template
Template Parameters
Class Template Instantiation
Non Type Parameter Conversion
Standard Template Library
STL Components
Generic Programming
STL Elements of a Simple Program
Simple STL Program
Map Container
Input/Output in C++
Input/Output in C++
Built-in Stream Objects
Output Operator <<
Input Operator >>
Character Input
String Input
Formatted I/O
Streams Hierarchy (Simplified)
File I/O
File Opening
Integer File Copy
Character File Copy
Overloading Stream Operators
Implementing Overloaded Stream Operators
Practical Aspects of C++ Programming
Interfacing C++ to Other Languages
Calling C from C++
_cplusplus Macro
Calling C++ from C
Interface Module for Stack Class
Namespace Collisions
ANSI Namespace
Reliability Philosophies of Languages
Prototypes and Type Checking
Constant Types
Access Control in C++
Reviews and Inspections
Inspections and C++
Testing Strategies for C++
Performance Considerations
Class Libraries
Advanced Polymorphism and Inheritance
Good Class Design
String Class
Public Inheritance
Public Inheritance Problems
Inheritance and Semantics
Private Inheritance
Composition vs. Private Inheritance
Templates vs. Inheritance
Protected Inheritance
Implementation Encapsulation
Interface Inheritance
Exception Handling
Exception Handling
try and catch
Exception Flow of Control
Context and Stack Unwinding
Handling Exceptions in best Context
Benefits of Exception Handling
Unhandled Exceptions
Clean Up
Multiple Catch Handlers
Runtime Type Information
Runtime Type and Polymorphism
type_info Class
typeid Operator
Compiler Options
Safe Pointer Conversions
Dynamic Cast
New C++ Style Casts
Static Cast
Reinterpret Cast
Const Cast
Inheritance Hierarchies and Multiple Inheritance
Class Hierarchy in Smalltalk
Smalltalk Class Hierarchy (Simplified)
Collection Classers
Multiple Inheritance Solution
Basic Derivation
Ambiguities in Multiple Inheritance
Resolving Ambiguity
Duplicate Subobjects
Virtual Base Classes
Applications of C++ Concepts
Orthodox Canonical Form (Review)
Object Validation
String Class
Smart Strings
Reference Counting
Reference Counting Rules
Smart String Pointer
Generic Smart Pointers
Constructing Smart Pointers
Smart Pointer Difficulties
An Overview of Templates
Overloading Functions
Template Functions
Specializing a Template Function
Disambiguation under Specialization
Template Classes
An Array Template Class
Instantiating a Template Class Object
Friends of Template Classes
Templates with Multiple Type Parameters
Non Class-type Parameters for Template Classes
Comments Regarding Templates
Templates and Inheritance
Overview of STL
History and Evolution
New Features
The Standard Template Library
Generic Programming
Design Goals
Header Files
STL Components
Compiling STL Code
Examples from STL
find – list
Overriding the Default Comparison
Function Objects
STL Containers
Vector Operations
deque as Stack
deque Functionality
Generic Programming
Tradeoff with Lists
List Memory Allocation
list Functionality
Associate Containers
Sets with User Defined Objects
Multisets (Bags)
STL Iterators
Template Version
String Version
A Generalization of Pointers
STL Iterators
Input Iterators
Output Iterators
Forward Iterators
Bidirectional Iterators
Random Access Iterators