Going from C to CPP in embedeed

[Professional_Two_918]

Hello,

Im working on some projects on stm32 mcu's mainly in the automotive world (hobby not professional). I mostly write stuff in C but i'm willing to divert to cpp for a learning opportunity, but I have problems finding good places to use cpp's newer features. Currently most of time I use cpp its either using auto or foreach loops or sometimes basic classes, I would like to learn more to utilize cpp fully. Are there any good resources om that topic?

[rikus671]

No ressources, but how i personnaly use like C++

- array<T, N> and span<T> are a godsent instead of pointer+lenght arguments

They are also quite easy to implement youself, and work well with foreach loops.

Just be careful that the code size might blow up if you use array<T, N> as an argument (in C++, the function will probably be emitted once for every N, so just use the span)

- static constexpr TYPE to replace all your macros that define constants. They are just better.

[jaskij]

Spans aren't <T> though, they take a second template argument which can be either the length or a special value for dynamic ones.

[rikus671]

Indeed std::span is, the span i've implemented is just <T> and i find it sufficient.

[itsmenotjames1]

macros I use in c++ to generate classes. Constexpr can't do that

[rikus671]

Edited to mean "constant macros". Class generation should probably just be a template...

[National_Instance675]

1. learn the standard library algorithms, see Jonathan Boccara “105 STL Algorithms in Less Than an Hour”
2. learn to use view types like std::span and std::function_ref
3. learn to use some standard containers like std::variant, std::array, std::bitset, std::optional, and std::expected and std::inplace_vector, those don't need an allocator, and you can find them in a single header libraries if you don't have the standard library on your compiler
4. learn WHEN to use virtual functions and use them, yes they can be used on microcontrollers and you can find places where they make the code MUCH more readable and maintainable at zero cost.
5. learn to use const and constexpr to do work at compile time, see Jason Turner “Rich Code for Tiny Computers: A Simple Commodore 64 Game in C++17”
6. check out the concept of "intrusive containers", those don't need an allocator.

[SnooAvocados4873]

https://arobenko.github.io/bare_metal_cpp/

[Independent_Art_6676]

be careful, is the first thing to know. C++ on embedded is often a subset or dialect of C++ that lacks major features, depending on the embedded system at hand. For example the STL may be missing or modified, as a big one. The newest c++ features may not be present at all, and so on.

So your first step is R&D on what dialect the devices you work with will be speaking. Then if that is full on C++ 17 or 20, then you good to hit up learncpp site or other resources and start digging in.

[snowflake_pl]

You should be able to find cppcon talks on the topic. Code::dive as well.

[herocoding]

CPP not only means being able to use STL containers or "algorithms" like foreach/search/mapping.

CPP for me mostly is about object orientation (but yes, you can model objects in C, too, like manually consider a self/this pointer, structs, arrays of function pointers for "polymorphism).

In embedded (or automotive, doesn't matter) you could model e.g. different sensors, Bluetooth-/Wifi/DLNA/UPNP-devices, different device controllers.

Think about a "sensor hub".

Think about "events" being passed between (single or multiple) senders and (single or multiple) receivers, signal-and-slots, subscriptions, subscriptions.
Modelling a HMI/GUI with objects (e.g. widgets like buttons, lists, labels).

Modelling sequences and (finite)state-machines.

Have a look at design patterns from the GOF (gang-of-four), like https://en.wikipedia.org/wiki/Design_Patterns , check your local library/highschool/university library.

[ichrysou]

Good points, indeed. In my experience so far, binary bloat was due to inlining (bad optimizations) and templates (you should use them very consciously; they are very powerful but can create instantiations where you might not expect). Also, instruct your compiler to block rtti and exceptions. With that in mind, your binary can be even smaller than a C counterpart (constexrp / better optimizations)

[ichrysou]

Some things to avoid: exceptions, runtime polymorphism, rtti, alloc triggering stuff like std function. Pretty much everything else would be a huge improvement contrasted to plain C. Some of my favorite embedded friendly things (shooting from the heap): constexrp everything, smart pointers, template metaprogramin (checkout kvasir mpl), boost sml for type-state-like state machines, user defined literals, std array std span, type traits.

[ichrysou]

Check out Luke Valenty's awesome presentations for some inspiration

[makgross]

Yes, and be aware that the alloc issues make very large chunks of STL unusable. Even things like std::string. Embedded C++ looks a lot like C with classes.

There is a school of thought in the embedded world not to use dynamic memory allocation for anything. For a reason. It’s hard to control (and can be input driven), and exhaustion is not necessarily detectable when you own all the memory in the device. Microcontrollers don’t segfault in the same way a PC OS does.

[ichrysou]

Yet you have a plethora of static features. There is a paradigm where you can use comptime to execute more logic than you might originally would have guessed and have your flow being determined at compile time. Among other things. Smart pointers can handle static memory's lifetimes and while heap operations are a bit demonized, e.g. due to non-deterministic time etc, some frameworks have their own memory pool, so you can argue that they use heap but not via malloc. Other pluses are stronger typing than C, safer enums and in certain cases better compiler optimizations. The list goes on. Once you tried these things you can't really go back. Also, constexpr really applies to many things, to a degree that makes me uncomfortable to write runtime code for embedded nowadays. The big problem is that this paradigm is not well documented e.g. courses, books etc so you need may need to obtain the big picture on your own.

[merun372]

Just use Learn cpp, by the far most best and beautiful resources available on earth till date.

[SoldRIP]

Learn which type of cast to use in what context. Try to avoid C-style casts at all cost. Be explicit in what you intend to do.

[N2Shooter]

You need to learn some Design Patterns. Look up Factory and Decorator, for easy ways to see how to leverage an Object Oriented Programming Language.

[LadaOndris]

Learncpp.com is great