Top 5 Beste inzichten van Bjarne Stroustrup over Embedded C++ programmering

Richard kreeg samen met andere studenten Embedded Systems Engineering tijdens een zomerschool van twee weken in Aarhus Denemarken de kans om de nieuwste en beste functies van hedendaags C++ (versie 26) te verkennen. Hij had ook de mogelijkheid om direct te leren van de persoon die de taal heeft uitgevonden. "Dit gebeurt je toch maar een keer in je leven?" 

Daarnaast bood dit programma hem de mogelijkheid om internationale kennis op te doen in een korte, intensieve cursus. "Perfect voor degenen onder ons die geen volledig semester in het buitenland kunnen volgen."

Richard deelt graag de meest spannende inzichten die hij uit deze cursus heeft gehaald. "Dit zijn mijn persoonlijke inzichten, dus je kunt deze onderwerpen op een andere manier tegenkomen wanneer je dieper in C++ duikt, specifiek binnen de context van embedded systemen. Hopelijk maakt dit je net zo enthousiast over nieuwe concepten in C++ als ik!"

Een van de eerste dingen die we behandelden, was generiek programmeren, wat essentieel is voor het creëren van schaalbare en herbruikbare code. Het idee is om je code flexibel te maken door gebruik te maken van sjablonen, zodat je met verschillende datatypen kunt werken zonder dezelfde logica steeds opnieuw te hoeven schrijven.

Bijvoorbeeld, als je een dashboard voor een embedded apparaat ontwerpt, zeg een eenvoudige lay-out met knoppen en een achtergrond, kun je sjablonen maken voor de vormen en maten van de UI-elementen. Tijdens compile-tijd kun je de eigenschappen specificeren (zoals grootte, kleur en positie), die je niet tijdens runtime zou aanpassen.

Hier is een klein voorbeeld van een generieke functie in C++:

template <typename T>
T add(T a, T b) {
     return a + b;
}

Met deze functie kun je integers, floats of zelfs aangepaste datatypen optellen. Meerdere datatypes in één functie! Bjarne benadrukte dat sjablonen een van de sleutels zijn tot het schrijven van efficiënte, herbruikbare code. Het was voor mij een eye-opener om te zien hoe dit concept complexe systemen kan vereenvoudigen.

Het doel van dit principe is om je programma’s flexibeler en schaalbaarder op te zetten. Op embedded platformen is het voordeel dat compile-time gebaseerde programma's meer deterministisch zijn. Dus robuster dan dynamische geheugen gebruik, waarbij foutgevoeligheid in het algemeen hoger is.

Daarna bespraken we het krachtige principe van RAII (Resource Acquisition Is Initialization). Het draait om het beheren van resources zoals geheugen, data-access-objecten voor externe connectiviteit en gerelateerde objecten. Het doel van deze aanpak is om objecten die niet langer nodig zijn, correct op te schonen.

Bjarne liet zien hoe dit concept cruciaal is om geheugenlekken en crashes te voorkomen. Vooral in embedded systemen kan dit catastrofale apparaatstoringen veroorzaken, met ernstige gevolgen, denk aan storingen in kritieke luchtvaartsystemen.

Met RAII zorgt C++ ervoor dat toegewezen resources automatisch worden vrijgegeven wanneer een object buiten scope gaat. Briljant, toch? (normaal in andere programmeertalen zoals Java en C#).

Praktische tips:

• Gebruik slimme pointers, nooit een rauwe pointer (ook wel “naked pointer” genoemd)
• Maak gebruik van de nieuwste semantiek en mechanismen van de C++-taal

Let op dat er een klein geheugenoverhead is, maar Bjarne legde uit dat dit meestal niet significant is voor je toepassing. Deze eenvoudige maar krachtige aanpak is een van de redenen waarom C++ zeer efficiënt blijft voor resource-beperkte toepassingen. Je behoudt de prestaties van pointers, maar met extra beschermingsmechanisme.

Bjarne heeft een heel duidelijke filosofie over hoe C++ geschreven moet worden: de code moet zowel leesbaar als efficiënt zijn.

Hij benadrukte het belang van code die niet alleen werkt, maar ook gemakkelijk te onderhouden en uit te breiden is. Dit betekent schrijven in kleine, modulaire componenten, wat helpt om “spaghetti-code” te voorkomen en toekomstige updates veel eenvoudiger maakt.

Door je code op te splitsen in kleinere, zelfstandige stukken, wordt het makkelijker om elk deel te debuggen en te testen. Schrijf functies die logisch zijn in de context en geen opmerkingen of documentatie nodig hebben.

Een van de uitdagingen in embedded systemen is het efficiënt en praktisch omgaan met fouten. In tegenstelling tot desktoptoepassingen kun je je geen uitgebreide logsystemen veroorloven of overal exceptions gooien. In plaats daarvan stelde Bjarne voor om lichte foutafhandelingsmethoden te gebruiken, zoals het teruggeven van foutcodes of het gebruik van optionele types.

Een voorbeeld met std::optional:

std::optional divide(int a, int b) {
            if (b == 0) {
               return std::nullopt; // Do not return a value.
            }
              return a / b;
          }

Bjarne raadt ook aan om een hiërarchische foutafhandeling te creëren, zodat fouten worden doorgegeven aan de hogere abstractie lagen, die de logica bevatten over wat te doen als een fout optreedt. Deze aanpak houdt de foutafhandeling eenvoudig en efficiënt, wat cruciaal is bij het werken aan systemen met beperkte verwerkingskracht en geheugen, zoals embedded apparaten. Het was fascinerend om van Bjarne zelf te horen hoe C++ evolueert om dergelijke toepassingen te ondersteunen.

Tot slot doken we in prestatie-optimalisatie van code, een belangrijk onderwerp bij het bouwen van grootschalige systemen. In resource-beperkte omgevingen telt elke verbetering, en Bjarne deelde waardevolle tips over het optimaliseren van C++ code voor snelheid en geheugenefficiëntie.

Een belangrijke strategie is het minimaliseren van dynamische geheugenallocatie. Vermijd bijvoorbeeld het gebruik van new of malloc, tenzij noodzakelijk. Kies in plaats daarvan voor stack-allocatie of vooraf toegewezen buffers om geheugenfragmentatie te voorkomen en runtime-overhead te verminderen.

Bjarne sprak ook over de kracht van constexpr en inline functies voor optimalisaties tijdens compile-time. Door de compiler bepaalde expressies van tevoren te laten evalueren, bespaar je kostbare verwerkingstijd tijdens de uitvoering.

Snel voorbeeld van constexpr in actie:

constexpr int square(const int x) {
                  return x * x;
      }

Tijdens de cursus hebben we meer optimalisaties uitgevoerd op zoekalgoritmen zoals vectors, lists, arrays en sets, maar dit is minder relevant voor embedded apparaten. De resultaten en testopstellingen hiervan zijn op mijn GitHub pagina terug te vinden, met een link naar de repository.

Leren van Bjarne Stroustrup zelf was een ervaring die ik nooit zal vergeten. De inzichten die ik opdeed over generiek programmeren, RAII, foutafhandeling en optimalisatie hebben mijn manier van programmeren in C++ compleet veranderd. Ik hoop dat deze blog jou ook inspireert om de nieuwste functies en concepten te gaan uit proberen!

Als je net begint met C++, laat je dan niet afschrikken door deze nieuwe functies! Begin met de basis, experimenteer en blijf vooral leren. C++ is een ongelooflijk krachtig hulpmiddel, en het beheersen van de moderne functies zal je op weg helpen om een bekwame en zelfverzekerde programmeur te worden.

Ben je klaar om de wereld van modern C++ te verkennen? Of heb je vragen?

• Neem contact met mij op (Richard Kroesen) via mijn LinkedIn