To get the most out of this chapter, I strongly recommend using Compiler Explorer (https://godbolt.org/) as you read through the examples. Select GCC as your compiler and target x86 architecture. This will allow you to see standard output (stdio) results and better observe the code’s behavior. The examples from this chapter are available on GitHub (https://github.com/PacktPublishing/Cpp-in-Embedded-Systems/tree/main/Chapter01).

In the mid-60s, the simulation programming language SIMULA introduced classes and objects to the world of software development. Classes are abstractions that allow us to represent real-world concepts in programming in a concise way, making the code more human-readable. In embedded development, UART, SPI, TemperatureSensor, PidController, and TemperatureController are some concepts that can be implemented as classes. SIMULA also introduced hierarchical relationships between classes. For example, PT100 class is also a TemperatureSensor class, and TemperatureController class has a member instance (object) of TemperatureSensor and a PidController. This became known as object-oriented programming (OOP).

In reflecting on the evolution of programming languages, Bjarne Stroustrup, the creator of C++, shared his approach to designing C++. Stroustrup aimed to bridge the gap between high-level abstractions and low-level efficiency. He said the following:

...

Historically speaking, C++ started as C with Classes. The first C++ compiler, Cfront, converted C++ to C, but that was a long time ago. Over time, C and C++ evolved separately and are now defined by separate language standards. C has maintained its simplicity, while C++ has become a modern language that enables abstract solutions for problems without sacrificing performance levels. But C++ is still sometimes called C with Classes, which implies that there is no added value in C++ except the classes.

The C++11 standard was released in 2011, and it is the second major version of C++. It is packed with features that modernize the language, such as range-based loops, lambdas, and constexpr. Subsequent releases, C++14, C++17, C++20, and C++23, kept modernizing the language and introducing features that make C with Classes merely a distant predecessor of modern C++.

Modern C++

To demonstrate that C++ is not just C with Classes, let’s explore a couple of...

The term bloatware describes unwanted software that is preinstalled with an OS on a device. Unwanted software in the world of programming describes code inserted in a binary by a framework, a library, or a language construct itself. Language constructs in C++ that are blamed for causing code bloat are constructors, destructors, and templates. We will analyze these misconceptions by examining assembly output generated from C++ code.

Constructors and destructors

The first thing that comes to mind to non-C++ developers when you mention C++ is that it is an object-oriented language and that you are bound to instantiate objects. Objects are instances of classes. They are variables that occupy memory. Special functions, called constructors, are used to construct or instantiate objects.

Constructors are used to initialize objects, including the initialization of class members, and destructors are used to clean up resources. They are tightly tied to...

C++ is guided by the zero-overhead principle. The only two language features that do not follow it are RTTI and exceptions, and that’s why compilers support a switch for turning them off.

The zero-overhead principle is based on two statements that we established in this chapter:

• You don’t pay for what you don’t use
• What you do use is just as efficient as what you could reasonably write by hand

RTTI and exceptions are disabled in most embedded projects, so you don’t pay for them. Using generic types and templates is a design choice and is no more expensive than writing individual types by hand (ring_buffer_int, ring_buffer_float, and so on), but it lets you reuse the code logic for different types, makes the code more readable and easier for maintenance.

Working on high-risk systems is not a reason to disable compiler optimization capabilities. Code functionality needs to be verified whether we are building a program...