C++: Advanced Development Skills (5 day) UK Classes & Lessons (Languages: C++)

About this class

C++ is the standard language for implementing object-oriented designs, but although based on C, C++ introduces many subtle syntactic and design issues. For developers whose C++ experience goes back further, many of the changes as a result of standardisation make standard C++ a very different programming environment.

This course will keep the audience abreast of these changes. It covers four main areas: new and advanced language features
using the standard library
implementing object-oriented concepts and patterns in C++
effective C++ programming techniques and idioms. It also suggests ways to maximise efficiency, code quality, and reusability.

This a comprehensive five-day course with a combination of lectures and practical sessions for each chapter to reinforce the topics covered throughout the course. The practicals use code skeletons, so that you can concentrate on specific C++ features.

What delegates will learn

Delegates will gain a greater understanding of the capabilities and potential pitfalls of the C++ language and will be more able to use C++ language features to write robust, quality software and you will also have a good grounding to make the best use of specific component technologies, such as COM and CORBA.

Contents of this class

Evolution of Standard C++

ISO C++
Changes to the core language
Overview of the standard library

C++ and OO Refresher

Abstraction and encapsulation
Composition and association
Inheritance and polymorphism
Patterns and idioms

Copying and Conversions

The staticcast, dynamiccast, constcast and reinterpretcast keyword casts
Logical vs physical const-ness and the mutable keyword
Converting constructors and the explicit keyword
User defined conversion operators
Copy construction and assignment

Scope

Static class members
The Singleton pattern
Nested classes
Nested class forward declarations
The Cheshire Cat idiom
Namespaces

Delegation Techniques

The Object Adapter pattern
The Null Object Pattern
The Proxy pattern
Overloading the member access operator
Smart pointers
The Template Method pattern
Factory objects

Subscripting Techniques

Overloading the subscript operator
Overloading with respect to const-ness
Smart references
Multi-dimensional subscripting
Associative containers

Template Functions

Using and implementing generic algorithms with template functions
Overloading and specialising template functions
Template instantiation and linkage

Template Classes

Using and implementing generic types with templates classes
Multiple template parameters
The standard vector, list, pair, and map template classes

Iterators and Algorithms

The need for Iterators
The standard library (STL) iterator model
Generic algorithms using iterators
STL algorithm pitfalls
Introduction to function objects

Exception Handling

Classifying and handling exceptions
Catching and throwing exceptions
The standard exception class hierarchy
Uncaught exceptions
Strategies for handling exceptions

Exception Safety

Resource acquisition idioms for exception safety
Exceptions in constructors
Exceptions in destructors
Exception safe classes
STL exception safety guarantees

Memory Management

Object life cycle
Allocation failure
Customising memory allocation
Optimising allocation for a class through caching
Derivation safe allocation
Controlling timing of construction and destruction

Reference Counting

Reference counting shared representation
Reference counted strings for copy optimisation
Subscripting issues
Smart pointers for simple, automatic garbage collection

Inheritance Techniques

Subtyping vs subclassing
Abstract and concrete base classes
Inheritance scoping issues
Multiple inheritance
Virtual base classes
Interface classes
Mixin classes
Runtime type information (RTTI)
Private and protected inheritance
The Class Adapter pattern

Template Techniques

Templating on precision
Template adapters
Default template parameters
Template specialisation
Trait classes
Member templates
Non-type template parameters
Optimising template code space

Functional Abstraction

Traditional callbacks using function pointers
The Command pattern
More on function objects
Member function pointers