Click for commercial
licensing information.
Click for personal
purchase information.
Scott Meyers Training Courses
Effective C++ in an Embedded Environment
C++'s flexibility, modelling power, support for object-oriented and generic programming, and extensive tool set, make it attractive for embedded projects, but some developers worry about code bloat and hidden performance penalties. This seminar begins by confronting those issues directly, then moves on to demonstrate how C++ can improve the correctness, readability, and efficiency of embedded software, in some cases accomplishing what is literally impossible in C.
Course Highlights
Participants will gain:
- An understanding of how compilers implement virtually every part of the language.
- Knowledge of how to avoid code bloat from templates, exceptions, and other language features.
- Familiarity with how to use C++ with ROM, memory-mapped IO, ISRs and signal handlers, and custom memory management schemes.
- Examples of how C++ templates can provide powerful functionality difficult or impossible to implement in C.
- An overview of issues related to the use of C++ in safety-critical and real-time systems.
Who Should Attend
Designers and developers who are using or considering using C++ in embedded systems. Attendees should be familiar with major C++ language features (e.g., classes, virtual functions, inheritance, and templates), but no expertise is required.
Format
Lecture and question/answer. There are no hands-on exercises, but participants are welcome to use their computers to experiment with the course material as it is presented.
Length
Two full days (six to seven lecture hours per day).
Detailed Topic Outline
- Overview of "Embedded C++."
- C++ under the hood:
- The efficiency philosophy behind C++
- Detailed examination of virtual function implementation under single and multiple inheritance
- Overview of how all other language features are implemented
- Causes of code bloat and how to address them
- The crucial role of inlining
- Three approaches to interface-based programming:
- Virtual functions and runtime polymorphism
- Separate compilation and link-time polymorphism
- Templates and compile-time polymorphism
- Applying C++ in Embedded Systems:
- Rules for what can and cannot be ROMed
- Memory management:
- Issues: speed, fragmentation, leaks, exhaustion
- Static allocation
- Dynamic allocation:
- Writing custom versions of new and delete
- LIFO allocation
- Pool allocation
- Block allocation
- Other options: regions and variable-sized allocators
- Modeling memory-mapped IO (MMIO):
- Putting objects at specific addresses:
- Placement new
- reinterpret_cast
- Compiler extensions
- Modeling MMIO registers directly vs. indirectly
- Creating shadow registers
- Preventing common usage errors
- Generalizing via templates
- Putting objects at specific addresses:
- Implementing callbacks for C APIs (e.g., ISRs):
- C++ functions C APIs can call
- Linkage and exception issues
- Approaches and their pros/cons:
- Using virtual functions
- Using std::tr1::function objects
- Overview of TR1 and Boost
- Interesting template applications:
- Generating cost-free type-safe wrappers for void*-based code
- Performing compile-time dimensional unit compatibility analysis
- Specifying finite state machines (FSMs)
- Considerations for safety-critical and real-time systems
- Resources for further information
For more information on this course, contact Scott directly.