This PDF document contains the presentation materials from Scott
Meyers' two-day training course Effective C++ in an Embedded
Environment.
It provides an in-depth examination of how C++ can be applied in embedded systems, including costs of language features,
ROMing, ISRs, memory management, safety-critical and real-time considerations, and more.

In Stock.
The PDF is ready for immediate download.

Buy it now

Features

Same content as the training course: The PDF you'll
get is an exact snapshot of Scott's full-color training materials on the
day he generates the PDF. You'll get not only the
slides Scott shows in class, you'll also get the accompanying notes—the
very ones Scott uses. To see exactly what you'll get you can
view a free sample.

No DRM: You may copy the PDF to as
many devices as you like, annotate it in any way you want, print it in part
or in full as many times as you choose. Because the PDF is for your
personal use only, you are not permitted to provide copies to friends or
colleagues, may not install it on servers for public access, can't use it
as the basis for presentations, etc., but we trust you to adhere to these
restrictions; the PDF itself doesn't try to prevent unauthorized uses. (For
more permissive usage options, consider licensing
the materials.)

Free updates for life: You are entitled to
free updates to the materials as long as Scott produces them.
Major revisions are included, so you won't have to pay again later for a "new edition."

Volume discounts: Want a copy for every member of your team or department? Discounts of 30-50% off single-PDF prices apply to purchases of as few as 10 copies. As the saying goes, the more you buy, the more you save! Consult the discount schedule for details.

About the course

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.

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

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

Sources for Additional Information

About the author

Scott Meyers
is one of the world's foremost
authorities on C++ software development. He provides training and
consulting services to clients worldwide.