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.
Upcoming Meetings
There are no upcoming meetings for this course. Contact us to schedule this course, which will be customized specifically for your organization.
info@hackerupro.comModules
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.