This is an example of a simple banner

Training: Programming Objects with C++, Advanced

Ref. CPP-02
Duration:
5
 jours
Exam:
Not certifying
Level:
Avancé

Advanced Object-Oriented Programming in C++ Training

The Advanced Object-Oriented Programming in C++ course is designed for developers who want to fully master the language’s advanced techniques. This training will help you strengthen your foundations while exploring modern methods for designing high-performance, maintainable applications. You will learn to leverage the power of OOP, templates, and the Standard Template Library (STL) while applying industry-recognized best practices.

Enhance your advanced C++ skills

Through this Object-Oriented Programming in C++ course, you will develop your ability to structure your code effectively and optimize its execution. You will understand how to manage memory, use smart pointers, handle exceptions, and apply proven design patterns. The different sections of the program will guide you in implementing advanced concepts such as multiple inheritance, delegation, decoupling, and design heuristics.

Participant Profiles

  • Software Developers
  • C++ Programmers
  • Software Architects
  • Systems Designers
  • Embedded Systems Engineers

Objectives

  • Apply advanced concepts of OO designs
  • Be able to write and maintain C++ programs
  • Write robust, maintainable, elegant and efficient C++ code
  • Be able to deploy good C++ programming practices
  • Be able to use the advanced features of the C++ programming language
  • Be able to implement advanced Object-Oriented techniques in C++ to realize efficient and flexible applications
  • Leave with skills needed to develop industrial C++ applications

Prerequisites

Course Content

Module 1: Language History and C++11/14

  • History of C++
  • Versions
  • New in TR1
  • New in C++11
  • New in C++14

Module 2: Language Review and Best Practice: Part I

  • Object-Oriented Programming
  • Constructors and Destructors
  • New and delete

Module 3: Basic Inheritance

  • Interface vs. Implementation
  • Type Inheritance
  • Implementation Inheritance
  • Proper Use of C++11 final and override
  • Virtual Destructors: When and Why?
  • Inheritance Guidelines

Module 4: Correct Use of Well Known Language Features

  • Pointers vs. References vs. Value
  • Proper Use of const
  • Proper Use of Inline Functions
  • Proper Use of static
  • Proper Use of Default Parameters
  • Proper Use of friend
  • Proper Use of namespace
  • The C++ Way to Cast
  • Proper Use of Operator Overloading
  • Copy Constructor: Why/When?
  • Assignment Operator: Why/When?
  • The Law of The Big Three

Module 5: Exceptions

  • Lessons from Traditional Error Handling
  • Object-Oriented Error Handling
  • Throw, try and catch
  • Design of Exception Hierarchies
  • Proper use of Rethrow
  • Using unexpected
  • Exception Pitfalls
  • Exception Guidelines

Module 6: Templates

  • Template Classes Definition
  • Template Classes Implementation
  • Parametrized Classes
  • Templates and Non-Type Parameters
  • Template Guidelines
  • Templates and Plain Functions
  • C++ Template Function

Module 7: Standard Template Library (STL)

  • STL String
  • STL Components
  • Sequence Containers
  • Use of Iterators in STL
  • Example of Algorithms
  • Initialization of Containers
  • Performance Profiles of Sequence Containers

Module 8: STL Algorithms

  • STL vs Boost
  • Parameterization of Algorithms
  • Using Functions
  • Using Function Objects
  • Using Lambda Expressions
  • Library of Selected Algorithms
  • Contributing Algorithms

Module 9: STL Associative Containers

  • Set
  • Multiset
  • Map
  • Multimaps

Module 10: STL Functors, Allocators and More

  • Standard Exception
  • Functors
  • Library Provided Function Objects
  • Using STL Function Objects and Binders
  • Negators
  • Allocators
  • Complex Number
  • Smart Pointers

Module 11: Efficiency: Temporary Objects

  • Temporary Objects: The Problem
  • Various Techniques to Avoid Temporaries
  • STL String: How to Avoid Creation of Temporaries
  • C++11: Move Semantics
  • Miscellaneous Techniques to Avoid Temporaries

Module 12: Memory Management

  • How Does C++ Use Memory?
  • Basic Guidelines
  • Implementation of Singletons in C++
  • Efficient Use of Smart Pointers
  • Overloading new and delete
  • Memory Management
  • The Importance of Data Layout

Module 13: Hot vs. Cold Memory

  • Miscellaneous Efficiency Techniques
  • Design Concerns
  • Flexibility vs Performance
  • Lazy Evaluation
  • Eager Evaluation
  • Copy on Write Techniques
  • Data Layout Revisited
  • Modern Hardware and Cache Pipelines
  • The Effect of Data Structures and Algorithms
  • Postcondition and C++
  • Efficiency Profiles of Libraries
  • STL and Performance
  • Latency
  • Cost and Benefits of Threads
  • Asynchronous Programming
  • Futures

Module 14: Delegation

  • Concept of Delegation
  • Delegation in C++
  • Simple Delegation
  • Static Delegation
  • Superclass Delegation
  • Subclass Delegation
  • Issues With Subclass Delegation in C++
  • Object Delegation
  • Strategy Pattern
  • C++ and Strategy
  • State Pattern
  • C++ and State
  • Design of Composite
  • Composite and Delegation
  • Other Delegation Patterns

Module 15: Decoupling

  • What is Coupling?
  • Kinds of Coupling
  • Identity Coupling
  • Identity Coupling: Object Lifetimes
  • Change of Identity
  • Type Coupling
  • Implementation Coupling
  • Interfaces and Implementations
  • Decoupling by Example

Module 16: Advanced Inheritance

  • Multiple Inheritance of Interfaces
  • Multiple Inheritance of Implementation
  • Shared Properties
  • Resolving Ambiguity
  • Virtual Inheritance
  • Multi Methods
  • Double Dispatch
  • Use of RTTI
  • Rules and Guidelines
  • Inheritance of Baseclass Methods
  • Change of Methods
  • Contracts and Inheritance
  • Contracts and Subtyping
  • Variations of Method Arguments
  • Rules for Method Arguments
  • Rules for Changing Return Types
  • Cancellations of Methods

Module 17: Design Heuristics

  • Object-Oriented Design Guidelines
  • Reflecting Client’s View
  • Polling
  • Express Interfaces Through Objects
  • Value Objects
  • Class Invariants
  • Abstract Base Classes
  • Classes and Interfaces
  • Design Interfaces Between Base and Derived Classes
  • Classes Cohesiveness

Documentation

  • Digital courseware included

Lab / Exercises

  • During the course participants are encouraged to actively participate in the learning experience by running example files during lectures and performing coding challenges during labs. Each lab session allows you to compare your solution to the instructor’s

Complementary Courses

Eligible Funding

ITTA is a partner of a continuing education fund dedicated to temporary workers. This fund can subsidize your training, provided that you are subject to the “Service Provision” collective labor agreement (CCT) and meet certain conditions, including having worked at least 88 hours in the past 12 months.

Additional Information

Deepening key concepts of object-oriented programming

Object-oriented programming in C++ goes beyond creating classes and objects. It involves a thorough reflection on code structure and reusability. In a professional context, understanding inheritance, polymorphism, and delegation helps design more robust and scalable applications. This type of design also facilitates long-term project maintenance, a major advantage in environments where performance and reliability are essential.

Leveraging modern C++ features

The language has evolved significantly with C++11 and C++14, introducing improvements that change the way we code. Developers can now take advantage of lambda functions, smart pointers, and move semantics to optimize execution. These additions are not just technical details; they directly influence the quality and readability of the produced code.

Optimizing memory management

Efficient memory management remains a core aspect of C++ development. Knowing how to properly use smart pointers or implement techniques to reduce temporary objects helps limit memory leaks and improve program stability. These skills are essential for projects where performance and resource consumption are closely monitored.

Mastering the standard library and algorithms

The Standard Template Library (STL) provides a rich set of containers, iterators, and algorithms. Mastering these tools allows you to write more concise, clearer, and often faster code than custom implementations. Proper use of these components ensures better compatibility and easier maintenance while adhering to modern development standards.

Using models and templates for more flexibility

C++ templates offer a powerful approach to creating generic, reusable code. When used correctly, they reduce duplication and increase consistency between different parts of an application. However, they require understanding of subtleties such as non-type parameters or function specializations to avoid common errors and maintain good performance.

Improving performance and software design

Beyond syntax, effective C++ development relies on well-thought-out architectural choices. Reducing coupling, promoting class cohesion, and applying suitable design heuristics contribute to code stability and maintainability. Decisions made during the design phase have a direct impact on the quality and lifespan of a project.

Why this C++ OOP training is an asset for professionals

The skills developed in this training are in demand across many sectors, from embedded systems development to high-performance simulation. Mastery of advanced object-oriented programming in C++ enables professionals to deliver optimized and sustainable solutions while meeting the increasing demands for performance and software security.

FAQ

Is this training suitable for beginners in C++?
No, it is intended for developers who already have a good command of the language basics and OOP.

What is the benefit of mastering C++11 and C++14?
These versions bring modern features that improve code readability, performance, and safety.

Why learn advanced memory management?
Good memory management prevents leaks, reduces resource usage, and increases application stability.

Are the techniques taught applicable outside of C++?
Yes, many object-oriented design principles also apply to other languages, with some adjustments.

Which sectors are looking for experts in advanced C++?
Such profiles are found in aerospace, video game development, embedded systems, finance, and AI.

Is the STL library still relevant today?
Yes, it remains a key standard, highly optimized and compatible with the new features of the language.

Are models and templates difficult to learn?
They require some investment but provide great flexibility and reduce repetitive code.

Prix de l'inscription
CHF 3'550.-
Inclus dans ce cours
  • Training provided by an industry expert
  • Digital documentation and materials
  • Achievement badge
Mois actuel

lun15Sep(Sep 15)09:00ven19(Sep 19)17:00VirtuelVirtual Etiquettes de sessionCPP-02

lun15Sep(Sep 15)09:00ven19(Sep 19)17:00Genève, Route des Jeunes 35, 1227 Carouge Etiquettes de sessionCPP-02

lun20Oct(Oct 20)09:00ven24(Oct 24)17:00VirtuelVirtual Etiquettes de sessionCPP-02

lun20Oct(Oct 20)09:00ven24(Oct 24)17:00Lausanne, Avenue Mon repos 24, 1005 Lausanne Etiquettes de sessionCPP-02

lun24Nov(Nov 24)09:00ven28(Nov 28)17:00VirtuelVirtual Etiquettes de sessionCPP-02

lun24Nov(Nov 24)09:00ven28(Nov 28)17:00Genève, Route des Jeunes 35, 1227 Carouge Etiquettes de sessionCPP-02

Contact

ITTA
Route des jeunes 35
1227 Carouge, Suisse

Opening hours

Monday to Friday
8:30 AM to 6:00 PM
Tel. 058 307 73 00

Contact-us

ITTA
Route des jeunes 35
1227 Carouge, Suisse

Make a request

Contact

ITTA
Route des jeunes 35
1227 Carouge, Suisse

Opening hours

Monday to Friday, from 8:30 am to 06:00 pm.

Contact us

Your request