Gain insights into using Modern C++ for embedded programming. Learn about safety-critical systems, optimize performance, manage limited resources, and handle parallel execution effectively.

waleed1.tar.gz

C++11

C++ 17

Embedded Programming with Modern C++  is highly valuable for each professional programmer.

In the past, embedded and system programming have had their pitfalls, but modern C++ has been designed to be a better language for this type of development, addressing the previous pitfalls/requirements explicitly. What are these requirements? Embedded systems deal with safety-critical systems, meaning they must guarantee high performance combined with limited resources, while also working in parallel.

The scope of this course goes beyond just embedded programming. Developers who write servers, games, or trading systems may especially benefit from this course because they also have to deal with safety-critical systems, high performance, reduced resources, and parallel execution in their jobs.

To get the most out of the course, you only need a basic understanding of C++. Building off this understanding, this course goes over all the essentials of embedded programming with Modern C++.

Let's get started!

Embedded Programming with Modern C++

# Rvalues and Lvalues

**Rvalues** are
* Temporary objects
* Objects without a name
* Objects from which we can not get the address

If one of these characteristics holds for an object, it is an rvalue. On the other hand, values with a name and an address are **lvalues**.


* Lvalues can be on the left side of an assignment operator.
* Rvalues can only be on the right side of an assignment operator.

A few examples of rvalues:
```c++
int five= 5;
std::string a= std::string("Rvalue");
std::string b= std::string("R") +  std::string("value");
std::string c= a + b;
std::string d= std::move(b);
```

As previously stated, Rvalues are on the right side of an assignment. The value 5 and the constructor call `std::string("Rvalue")` are rvalues since we cannot determine either the address or the name of the value 5. The same holds for the addition of the rvalues in the expression `std::string("R") + std::string("value")`.

The addition of the two strings `a + b` is notable. Both strings are lvalues, but the addition creates a temporary object. A special use case is `std::move(b)`. The new C++11 function converts the type of the lvalue `b` into an rvalue reference.
## A Few Exceptions
Earlier, we stated that rvalues are on the right side of an assignment, and lvalues can be on the left side of an assignment. It is important to note that this is not always true:

```c++
const int five= 5;
five= 6;
```
Even though the variable `five` is an lvalue, it is also a constant, so it cannot be used on the left side of an assignment operator.

><img src="/api/collection/10370001/6066104977850368/page/4580102618742784/image/6441996354846720" width="35"> Lvalue references are declared by one `&` symbol. Rvalue references are declared by two `&&` symbols. Lvalues can be bound to lvalue references, and rvalues can be bound to rvalue references or constant lvalue references.

```c++
MyData myData;

MyData& lvalueRef(myData);

MyData&& rvalueRef(MyData());
const MyData& constLValueRef(MyData());
```
><img src="/api/collection/10370001/6066104977850368/page/4580102618742784/image/6441996354846720" width="35"> The binding of rvalues to rvalues references has higher priority.





In this lesson, we will discuss rvalue and lvalue references. 

Introduction

Safety-Critical Systems

High Performance

Reduced Resources

Several Tasks Simultaneously

Conclusion

Rvalue and Lvalue References

Rvalues and Lvalues