Advanced C++ Development Techniques

Prerequisites:

- Experienced C++ programmers wishing to substantially enhance their development skills.
- You must have solid and genuine experience of C++ including class definitions and member functions.
- Constructors and destructors
- References
- Virtual functions
- New and delete operators. Ideally, you will have attended one of our C++ programming courses and have been using C++ solidly for at least six months. You should also have an appreciation of object-oriented principles, possibly from attending the Object-Oriented Software Development or an object-oriented analysis and design course.

Course Description:

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.

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.

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.

This course includes the following modules:

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