Advanced Modern C++ Programming

BT121


5 Days

Download Full Syllabus Request a Quote
All Our Courses Now Also LIVE

Course Outline

C++ is the standard language for implementing object-oriented designs where performance is a priority. Although long-term language stability is an important feature of C++, it has nevertheless continued to be developed. C++ 11 introduced a number of significant language and library features to improve safety and performance. These features allow us to more precisely express concepts from a design directly in code. Although these changes could be considered incremental, in fact they allow and encourage a whole new approach to programming.

This course sets out from the beginning to embrace this new approach making full use of the facilities for writing well encapsulated robust code which is at the same time supremely efficient. The course is written from a developers rather than an academics perspective, following the design of a simple library and introducing language and library features as they are encountered. In the process virtually all language features are explored and most of the standard library. In addition a variety of design patterns are examined and good practices are emphasize. Although the course makes use of C++ 11/14 features throughout, most of the material is useful and relevant to pre C++ 11 users. 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. 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 practical avoid algorithmic difficulties so that delegates can concentrate on specific C++ features.

Upcoming Meetings

Modules

Starting Well
  • Version Control
  • Documenting Code
  • Static Analysis
  • Unit Testing
  • 64-bit Issues
  • C/C Library
  • Precompiled Headers
Robust Design
  • Single Responsibility Principle
  • Reducing Complexity
  • Encapsulation
  • Keeping Header Files Clean
  • Conditional Compilation
  • Coding Style
  • C++ 11 Game-Changers
Const, Copying and Conversions
  • Const Consistency
  • Logical VS Physical Const-ness and The Mutable Keyword
  • The Staticcast, Dynamiccast, Constcast and Reinterpretcast Keyword Casts
  • Converting Constructors and The Explicit Keyword
  • User Defined Conversion Operators
  • Copy Construction and Assignment
  • Efficiency - Copy Elision and Return Value Optimization
Move and Forward
  • R-Value Reference
  • Move Rather Than Copy
  • Compiler Synthesized Member Functions
  • Rule of Three / Five / Zero
  • std::swap, std::move and std::forward
  • Perfect Forwarding
Strong Primitive Types
  • Mission Statement For a New Design
  • Standard Libraries For Time and Date
  • Creating Strongly Typed Primitive Types
  • Class Definition Organization
Operator Overloading
  • Deriving Operators From a Sub-set
  • Global Functions for Binary Operators
  • Templates Operators
  • Template Parameter Deduction
  • Template Functions with Non-argument Type Parameters
  • Template Function Overloading & Specialization
  • Template Function Overloading & Specialization
  • Namespaces
Portable Integers & Robust Constructors
  • Language Specification for Integers
  • Discovering int size
  • Specifying int size
  • Template Classes
  • Template Class Specialization and Aliasing
  • Single Point Of Maintenance for Constructors
  • Argument Range Checking
  • Custom Literals
Exception Handling
  • Classifying and Handling Exceptions
  • Catching Exceptions
  • Throwing Exceptions
  • The Standard Exception Hierarchy
  • Uncaught Exceptions
  • Resource Acquisition and Release
  • Resource Acquisition is Initialization Idiom
  • Exceptions and Constructors
  • Copy Before Release Idiom
  • Exceptions and Destructors
  • Commit or Rollback Idiom
  • STL Exception Guarantees
Bitfields and Unions
  • Bitfields
  • Anonymous Union
  • Endianness and Bitfield Portability
  • Creating a Portable Bitfield
  • Template Parameter Checking
  • Type Traits
  • Static_Assert
Delegation Techniques
  • Delegation Principles
  • Composition
  • Adapter Patterns
  • Inheritance
  • Multiple Inheritance
  • Name Hiding
  • Virtual Inheritance
  • Interface Classes
  • Nested Classes
Statics and Global
  • Storage Class
  • Static Class Members
  • Stateless Classes
  • Static Local Variables
  • Global and Local Access
  • Problems with Global Variables
  • Safe Global Variables
  • The Singleton Pattern
  • Alternatives to Singleton
Volatile Variables
  • Memory Mapped IO
  • Volatile
  • Placement New
  • New and Delete Operators
  • Placing Objects in Memory
  • Allocating Without Exceptions
Multithreading Techniques
  • Multithreading Concepts
  • Creating Multiple Threads in C++
  • Creating and Managing Locks
  • Exception-Safe Lock Management
  • Simultaneous Reads with a Shared mutex
  • Thread-Safe Assignment
  • Atomic Variables
  • Condition Variables
  • Asynchronous Functions and Futures
  • Exceptions in Threads
Polymorphism
  • Abstract Base Classes
  • Benefits and Cost of Polymorphism
  • Template Method Pattern
  • Pure Virtual Functions
  • Smart References and Their Uses
  • Template Outward Conversions
  • The Curiously Recurring Template Pattern
  • Downcasting
Safe Association
  • Association for Independent Lifetimes
  • Structured Lifetimes
  • Unique_ptr
  • Wrapping New
  • 'Pointer' Function Parameters
  • Shared_ptr
  • Weak_ptr
  • Safe Copying with Association
Design Patterns
  • Composite
  • Cheshire Cat
  • Bridge
  • Null Object
  • Proxy
  • Lazy Initialization
  • Dependency Inversion
  • Factory
  • Dependency Injection
Functional Abstraction
  • Events and Callbacks
  • The Command Pattern
  • Functor Commands
  • Lambda, an Alternatives to Functors
  • Wrapping Traditional Callbacks
  • Member function pointers
  • Function Pointer Adapters
Containers
  • STL Container Classes
  • Container Selection
  • Container Functions
  • Special List and Map/Set functions
  • Iterators
  • Algorithms
  • Modifying Sort

Prerequisites

  • Solid recent experience in writing C++ for at least six months
  • Good appreciation of object-oriented principles
  • Be comfortable with new and delete operators, class definitions and member functions, constructors and destructors, pointers, references, virtual functions, function overloading, specialization, inheritance and polymorphism.

Upcoming Meetings

Describe & use template techniques for efficient generic coding”
Download Full Syllabus

Target Audience

    • Israel
    • Poland
    • USA
    • Russia
    • India
    Skip to content