Training Series: ‘Embedded Software Development in C++’

Learn how the right methodology and the efficient use of the programming language allow applying the advantages of the C++ programming language even on extremely small embedded platforms. The biggest challenge is the proper handling of the limited resources (especially memory).

Our intention is to show you how a C++ compiler works in detail. With this knowledge it is possible to work with C++ much more efficiently than with the C programming language. Since even on 8-bit microcontrollers, reusable software components that are implemented with C++ can be used with virtually no overhead compared to the same functionality when it is coded in C.

Flexible and Customized

With the successive building blocks, this training series is aimed at software developers with very different background: Depending on your experience you can get on later.

For in-house trainings (at your premises), we can also adapt the training topics according to your individual needs.

The training series is regularly organized as a public event after enough people have come together. So, just contact us if you are interested!

Block 1: Embedded C++ for C-Developers (3 Days)

This training block addresses C developers that are experienced in embedded development.

You get to know the syntactical features of C++ and their advantages compared to C, as well as basic concepts of object oriented software development. This includes the following topics:

  • C++ enhancements to C: new features (e. g. references, keyword const, namespaces, C++ style casts)
  • concepts of object oriented development - data encapsulation, concept of data visibility
  • classes, attributes, methods, operators
  • constructors and destructors
  • concepts for code reuse: aggregation, inheritance, multiple inheritance
  • virtual methods, dynamic polymorphism, abstract classes
  • Learn why C++ is the ideal language for embedded systems - efficiency analysis of C and C++ and evaluation of the resource costs for the following language concepts:
    • static methods
    • inline methods
    • inheritance
    • multiple inheritance
    • virtual methods / dynamic polymorphism
    • virtual inheritance
  • function and operator overloading, type conversion
  • copy constructor, assignment operator

Block 2: Using C++ for efficient Embedded Software Development (3 Days)

This training block continues the first training block and is also aimed directly at C++ developers who already know the language but have not yet used it for embedded development.

This block concentrates on the powerful code generation features of C++ templates and why they are a perfect tool for embedded software development. In addition, various sample solutions for typical embedded challenges are presented.

Among others, it covers the following topics:

  • resource costs of dynamic polymorphism
  • C++ templates
    • basics (function templates, class templates, template specialization)
    • pitfalls and resource optimization when using C++ templates
    • the concept of static polymorphism compared to dynamic polymorphism
    • resource considerations
    • traits and policies
  • embedded design patterns (e. g. scope locked pattern, intrusive lists)
  • implementation of drivers with interrupt handlers in C++
  • strategy for dynamic memory usage (overloading new and delete, usage of placement new)
  • optional: exceptions
    • operating mode
    • discussion about exception usage in embedded applications

Block 3: Embedded Software Development with reusable C++ Components (2 Days)

This training block is a smooth follow-up to training block 2 and teaches in detail how embedded applications can be developed with reusable software components.

Topics addressed:

  • finding building blocks: dissecting functionality in software components and identification of interfaces
  • implementation strategies for building blocks that avoid overhead
  • testing building blocks: applying unit tests for embedded applications in order to improve software quality
  • assembling building blocks: software component configuration and assembling them with the necessary glue logic
  • examples for generic embedded software components from the embedded software toolkit redBlocks


In all the training blocks, the obtained knowledge is deepened by practical exercises. In order to perform meaningful experiments for run-time efficiency and memory requirements of the respective language constructs, these exercises are performed using the simulator of IAR Workbench or the IDE uVision from Keil. In individually tailored training events, it is alternatively possible to use other development tools, which the participants are best accustomed to.