Auf meiner Lernreise in die Welt der Robotik ist eines meiner Ziele, mein angestaubtes C++-Wissen aufzubessern.
Heute schauen wir uns den std::vector an. Der std::vector ist ein praktisches Hilfsmittel, um in C++ Daten zu verwalten.
Man kann ihn mit der Liste in Python vergleichen. Im Gegensatz zum std::array ist der std::vector eine dynamische Datenstruktur, die wächst, wenn neue Werte hinzugefügt werden und die bisherige Kapazität nicht mehr ausreicht.

Historie

Den std::vector gibt es bereits ab C++98, er wurde von Alexander Stepanov entwickelt. Seit C++11 sind einige interessante Neuerungen hinzugekommen.

Include

Um einen Vector zu benutzen, wird der Header vector eingebunden:

#include <vector>

Deklaration

Der std::vector ist eine Template-Datenstruktur, d.h. wir müssen ihn mit dem Datentyp parametrieren, der eingefügt werden soll:

TEST(VectorTest, VectorInitialSize) {
    const std::vector int_vector;
    EXPECT_EQ(int_vector.capacity(), 0);
    EXPECT_EQ(int_vector.size(), 0);
    EXPECT_EQ(int_vector.empty(), true);
}

Die Kapazität und die Größe sind am Anfang 0; empty() gibt true zurück

Daten einfügen

Die einfachste Art, Daten in den Vector zu packen, ist die push_back()-Methode. Sie hängt ein neues Element an das Ende des vectors

TEST(VectorTest, VectorPushBack) {
    std::vector int_vector;
    int_vector.push_back(1);
    int_vector.push_back(2);
    int_vector.push_back(3);
    EXPECT_EQ(int_vector.size(), 3);
}

Mit der Insert-Methode kann an einer beliebigen Stelle im Vector ein Element eingefügt werden:

TEST(VectorTest, VectorElementInsert) {
    std::vector int_vector = {1,2,3};
    int_vector.insert(int_vector.begin(), 0);
    EXPECT_EQ(int_vector.at(0), 0);
}

Allerdings werden dann Elemente um jeweils eine Stelle verschoben (kopiert) was zur Laufzeit in O(n) führt, also O(n²).
Bei vielen Elementen kann es sich lohnen push_back + std::sort zu verwenden, das ist dann in O(n log n)
Zu beachten ist hier zudem, dass die Stelle an der eingefügt werden soll, nicht durch einen Index, sondern durch einen Iterator angegeben wird.

Daten auslesen

Grundsätzlich unterstützt vector sowohl den Index-Operator als auch die at()-Methode:

TEST(VectorTest, VectorGetElement) {
    const std::vector int_vector = {1,2,3,4,5};
    EXPECT_EQ(int_vector[2], 3);
    EXPECT_EQ(int_vector.at(2), 3);
}

Die at()-Methode ist zu bevorzugen, weil sie eine Exception wirft, wenn der Index nicht verfügbar ist.

TEST(VectorTest, VectorGetElementException) {
    const std::vector int_vector = {1,2,3,4,5};
    EXPECT_THROW((void)int_vector.at(10), std::out_of_range);
}

Wenn man am ersten Element im Vektor interessiert ist, kann die front()-Methode benutzt werden. Das letzte Element kann mit back() abgefragt werden.
Aber Vorsicht: auch hier solltest du prüfen, ob der vector nicht leer ist.

TEST(VectorTest, VectorElementBackFront) {
    const std::vector int_vector = {1,2,3};
    if (!int_vector.empty())
    {
        EXPECT_EQ(int_vector.front(), 1);
        EXPECT_EQ(int_vector.back(), 3);
    }
}

Daten löschen

Mit der Methode pop_back() löschst du das letzte Element aus einem Vektor.

TEST(VectorTest, VectorElementPopBack) {
    std::vector int_vector = {1,2,3};
    int_vector.pop_back();
    EXPECT_EQ(int_vector.size(), 2);
}

Mit der Methode clear() kann der komplette Vektor geleert werden. Die Size ist danach auch wieder = bzw. empty wieder true

TEST(VectorTest, VectorClear) {
    std::vector int_vector = {1,2,3};
    int_vector.clear();
    EXPECT_EQ(int_vector.size(), 0);
}

Kapazität vs Größe

Die Kapazität ist die maximal mögliche Anzahl von Elementen, die Größe die wirkliche Anzahl.
Je nach Compiler wird der Vector unterschiedlich vergrößert:
Clang und der GCC verdoppeln die Größe eines Vectors, sobald die Kapazität nicht mehr ausreicht, um ein weiteres Element einzufügen.

MSVC erhöht die Kapazität um lediglich 50 %.

Das Verhalten kann mit folgendem Code überprüft werden:

TEST(VectorTest, VectorPushBack) {
    std::vector int_vector;
    int_vector.push_back(1);
    int_vector.push_back(2);
    int_vector.push_back(3);
    EXPECT_EQ(int_vector.size(), 3);

#if defined(_MSC_VER)
    EXPECT_EQ(int_vector.capacity(), 3);
#elif defined(__clang__) || defined(__GNUC__)
    EXPECT_EQ(int_vector.capacity(), 4);
#endif

    int_vector.push_back(4);
    EXPECT_EQ(int_vector.size(), 4);
    EXPECT_EQ(int_vector.capacity(), 4);

    int_vector.push_back(5);
    EXPECT_EQ(int_vector.size(), 5);

#if defined(_MSC_VER)
    EXPECT_EQ(int_vector.capacity(), 6);
#elif defined(__clang__) || defined(__GNUC__)
    EXPECT_EQ(int_vector.capacity(), 8);
#endif

}

Beide Strategien haben Vor- und Nachteile

Wenn du lieber von vornherein eine explizite Größe vorgeben möchtest, kannst du die reserve()-Funktion benutzen. Dann wird im Vector für die konkrete Kapazität Speicher allokiert.

TEST(VectorTest, VectorReserve) {
    std::vector int_vector;
    int_vector.reserve(100);
    EXPECT_EQ(int_vector.capacity(), 100);
}

emplace_back

Jetzt wird es spannend. Wir haben bisher das push_back auf einfache Datentypen angewendet.
Was passiert aber, wenn wir Objekte in den Vector pushen?

std::vector str_vector;
str_vector.push_back("Hello world");

Hier wird der string erst erzeugt und dann nochmal kopiert. Das ist natürlich ineffizient, weil das initiale Objekt außerhalb des Funktions-Aufrufes nicht verwendet wird. Deshalb sparen wir uns seit C++11 die Kopie, indem wir emplace_back() verwenden.

TEST(VectorTest, VectorEmplaceBackString) {
    std::vector my_vector;
    my_vector.emplace_back("Hello");
    my_vector.emplace_back("World");
    EXPECT_EQ(my_vector.at(0), "Hello");
}

Quellcode

https://github.com/jboegeholz/modern_cpp/blob/master/tests/04_test_vector.cpp

Further Reading

Electronic Arts hat ihre STL-Implementierung geopensourct
https://github.com/electronicarts/EASTL/blob/master/include/EASTL/vector.h

The post So verwendest Du den std::vector – Modernes C++ appeared first on Creatronix.

Auf meiner Lernreise in die Welt der Robotik ist eines meiner Ziele, mein angestaubtes C++-Wissen aufzubessern.
Heute schauen wir uns das Konzept von std::array an.

Wie war es früher?

Vor C++11 musste man C-Style-Arrays benutzen:

TEST(ArrayTest, CStyleArray) {
    int my_int_array[3] = {1, 2, 3};
    EXPECT_EQ(my_int_array[0], 1);
    EXPECT_EQ(my_int_array[1], 2);
    EXPECT_EQ(my_int_array[2], 3);
}

Das hat natürlich ein paar Nachteile:

Sizeof kompliziert

Die Funktion sizeof() kann eigentlich nicht direkt für Arrays verwendet werden, da sie die Größe einer Datenstruktur in Bytes angibt.
Das können wir in folgendem Beispiel sehen. Ein Int-Array der Größe drei ist 12 Byte groß ein.
Ein Double-Array der Größe drei hat 24 Byte.

TEST(ArrayTest, CStyleArraySize) {
    int my_int_array[3];
    double my_double_array[3];
    EXPECT_EQ(sizeof(my_int_array), 12);
    EXPECT_EQ(sizeof(my_double_array), 24);
}

Deswegen musste man das Ergebnis von sizeof des Arrays noch mal durch die Größe des Datentyp teilen.

Decaying

Pointer Decay ist ein weiteres Problem von C-Style-Arrays.

In diesem Beispiel sehen wir, dass ein paar Zeiger an eine Funktion übergeben ist, Array nur noch durch den Zeiger repräsentiert wird.
Sizeof von diesem Datentyp ist normalerweise acht, weil es sich um einen 64 Bit Zeiger handelt.

int get_size(const int *arr)
{
    return sizeof(arr);
}
TEST(ArrayTest, CStyleArrayPointerDecay) {
    int my_int_array[3];
    EXPECT_EQ(sizeof(my_int_array), 12);
    EXPECT_EQ(get_size(my_int_array), 8); // decays to 64bit pointer
}

Unsicherer Indexzugriff

Auch der Zugriff auf die Daten wie Index Operator ist nicht ungefährlich, weil nicht überprüft wird, ob es sich um einen gültigen Index handelt.

D.h. es fliegt keine Exception sondern das Programm stürzt normalerweise ab.
Wenn man folgenden Code ausführt:

TEST(ArrayTest, CStyleArrayIndex) {
    int my_int_array[3] = {1, 2, 3};
    my_int_array[4] = 1;
    EXPECT_EQ(my_int_array[4], 1);
}

Bekommt man:

Process finished with exit code 134 (interrupted by signal 6:SIGABRT)

std::array – modernes C++

Jetzt wollen wir uns mal anschauen, wie das std::array funktioniert.

Seit C++11 kann man den header <array> inkludieren und bekommt die Möglichkeit, ein array zu definieren,
dass dem C-Style-Array recht ähnlich sieht. Auch der Zugriff auf die Elemente mit dem Index Operator ist identisch:

TEST(ArrayTest, StdArray) {
    std::array<int, 3> my_std_array = {1, 2, 3};

    EXPECT_EQ(my_std_array[0], 1);
    EXPECT_EQ(my_std_array[1], 2);
    EXPECT_EQ(my_std_array[2], 3);

}

Was macht std::array besser?

size()-Funktion

std::array besitzt eine size()-Methode, die die korrekte Größe des Arrays ausgibt:

TEST(ArrayTest, StdArraySize) {
    std::array<int, 3> my_int_array{};
    std::array<int64_t, 3> my_int_64_array{};
    EXPECT_EQ(my_int_array.size(), 3);
    EXPECT_EQ(my_int_64_array.size(), 3);
}

at()-Funktion

Die at()-Methode greift wie der Index-Operator auf das n-te Element zu:

TEST(ArrayTest, StdArrayAt) {
    std::array<int, 3> my_std_array = {1, 2, 3};

    EXPECT_EQ(my_std_array.at(0), 1);
    EXPECT_EQ(my_std_array.at(1), 2);
    EXPECT_EQ(my_std_array.at(2), 3);
}

Auch das Setzen der Elemente geht über die at()-Methode:

TEST(ArrayTest, AddElementsToArrayWithAt) {
    std::array<int, 3> my_array{};
    my_array.at(0) = 1;
    my_array.at(1) = 2;
    my_array.at(2) = 3;
    EXPECT_EQ(my_array[0], 1);
    EXPECT_EQ(my_array[1], 2);
    EXPECT_EQ(my_array[2], 3);
}

Gut ist, dass sie eine Exception wirft, wenn der Zugriff außerhalb des Arrays erfolgt:
Die Exception kann dann über ein try/catch zur Laufzeit gefangen werden.

TEST(ArrayTest, ArrayTestCatchException) {
    std::array<int, 4> my_std_array = {8, 7, 6, 5};

    try
    {
        std::cout << "Element at postion 4: " << my_std_array.at(4) << std::endl;
    }
    catch (const std::out_of_range& ex)
    {
        std::cerr << ex.what() << '\n';
        EXPECT_NE(ex.what(), nullptr);
    }
}

Arrays als Funktionsparameter

void power2(std::span arr)
{
    for (int & i : arr) {
        i *= 2;
    }
}
TEST(ArrayTest, StdArrayFunctionCall) {
    std::array<int, 4> my_std_array = {8, 7, 6, 5};
    power2(my_std_array);
    EXPECT_EQ(my_std_array[0], 16);
}

sort

Da sich ein std::array wie ein normaler STL-Container verhält, lässt sich das array mit std::sort sortieren:

TEST(ArrayTest, StdArraySort) {
    std::array<int, 4> my_std_array = {8, 7, 6, 5};
    std::sort(my_std_array.begin(), my_std_array.end());
    EXPECT_EQ(my_std_array[0], 5);
}

TEST(ArrayTest, StdArraySortWithRanges) {
    std::array<int, 4> my_std_array = {8, 7, 6, 5};
    std::ranges::sort(my_std_array);
    EXPECT_EQ(my_std_array[0], 5);
}

Beispiel aus der Robotik

https://github.com/jboegeholz/udemy_ros2_for_beginners/blob/3c082c605043155b7f617471a50bc3dbf3fa9929/src/my_cpp_pkg/src/led_panel_server.cpp#L47

Kompletter Code

https://github.com/jboegeholz/modern_cpp/blob/master/tests/02_test_std_array.cpp

The post So verwendest du std::array – Modernes C++ appeared first on Creatronix.

So, auf geht’s! Test Driven Development für C++ Projekte.

Google Test (oft auch als gtest abgekürzt) ist ein Test Framework, das von Google entwickelt wurde. 2008 wurde es als Open Source veröffentlicht, seit 2015 findest du es auf github.

Voraussetzungen

Um Google Test in deinen Projekten verwenden zu können, musst du CMake installiert haben. Zudem empfiehlt es sich, dein Projekt mit git zu versionieren, weil du dann Google Test als git Submodul installieren kannst.

Installation

cd my_project
git submodule add https://github.com/google/googletest.git external/googletest
git submodule update --init --recursive

CMake

cmake_minimum_required(VERSION 3.14)
project(my_project)

set(CMAKE_CXX_STANDARD 17)

add_subdirectory(external/googletest)
include(GoogleTest)
enable_testing()

add_executable(google_test_examples tests/00_google_test.cpp)
target_link_libraries(google_test_examples gtest_main)
gtest_discover_tests(google_test_examples)

Code

#include <gtest/gtest.h>

Standard Vergleiche

Standardmäßig vergleicht man gerne auf Gleichheit beziehungsweise Ungleichheit.

TEST(GoogleTestExamples, EXPECT_EQ) {
    const int a = 10;
    const int b = 10;
    EXPECT_EQ(a, b);
}

TEST(GoogleTestExamples, EXPECT_NE) {
    const int a = 10;
    const int b = 11;
    EXPECT_NE(a, b);
}

Auch bool’sche Ausdrücke lassen sich vergleichen, auf true oder false. Das wäre aber auch schon mit dem eingebauten Assert direkt in C++ möglich. Deswegen schauen wir uns spannendere Testfälle an:

Float und double vergleichen

TEST(GoogleTestExamples, EXPECT_FLOAT_EQ) {
    const float a = 10.0;
    const float b = 10.000001;
    EXPECT_FLOAT_EQ(a, b);
}

TEST(GoogleTestExamples, EXPECT_DOUBLE_EQ) {
    const float a = 10.0;
    const float b = 10.0000001;
    EXPECT_DOUBLE_EQ(a, b);
}

Exceptions testen

Schön ist es, dass Google Test auch das Testen von Exceptions unterstützt:

TEST(GoogleTestExamples, ArrayException) {
    constexpr std::array<int, 3> my_array = {1,2,3};
    EXPECT_THROW((void)my_array.at(10), std::out_of_range);
}

SIGABRT testen

void double_unique_ptr() {
    auto * p = new int(10);
    const std::unique_ptr<int> ptr1 {p};
    const std::unique_ptr<int> ptr2 {p};
}
TEST(MyUniquePointer, DoubleUniquePointer) {
    EXPECT_DEATH(double_unique_ptr(), ".*");
}

std::out abfangen

Wenn wir Code schreiben, der auf std::out schreibt, können wir mit CaptureStdoutdie Ausgabe abfangen:

#include <span>
#include <iostream>
#include <gtest/gtest.h>

void print(const std::span<const int> values) {
    for (const int v : values) {
        std::cout << v << " ";
    }
}
TEST(SpanTest, StdPrintExtrapolation) {
    testing::internal::CaptureStdout();

    const int arr[] = {1, 2, 3, 4, 5};
    print(arr);

    const std::string output = testing::internal::GetCapturedStdout();
    EXPECT_EQ(output, "1 2 3 4 5 ");
}

Test Fixtures

Wenn man schon etwas Erfahrung mit dem Erstellen von Tests hat, genießt man Features wie Test Fixtures.

Ein Test Fixture ist eine Methode, wie man für eine Vielzahl von Tests die Startbedingungen festlegen kann. Variablen initialisieren und Objekte instantiieren beispielsweise.

In klassischen Testframeworks wie JUnit oder auch Python Unittest muss man dafür die Setup-Methode der Testklasse verwenden. In modernen Testframeworks wie pytest, sind fixtures freistehende Funktionen.

In Google Test besteht ein Fixture aus einer Klasse die von ::testing::Test erbt und die SetUp()-Methode überschreibt.

class TestFixture : public ::testing::Test {
protected:
    void SetUp() override {
        speed = 100;
    }

    int speed{};
};

Dann können wir mit dem Test-Makro TEST_F das Fixture verwenden:

TEST_F(TestFixture, IncreasesSpeed) {
    speed += 50;
    EXPECT_EQ(speed, 150);
}

TEST_F(TestFixture, DecreasesSpeed) {
    speed -= 30;
    EXPECT_EQ(speed, 70);
}

Parametrisierte Tests

Parametrisierung Tests sind ein sehr wertvolles Werkzeug, gerade wenn man TDD benutzt, um seine Programme zu schreiben.
Bei the Rule of three führt man normalerweise eine Optimierung durch, sobald man dreimal das Gleiche getan hat.
Oft ist das der Aufruf einer neuen Funktion mit einem dritten Parameter.

Deshalb könnte dann hier ein parametrisierter Test drei Testfälle ersetzen.

class AbsTest : public ::testing::TestWithParam<std::pair<int, int>> {
    // no setup needed
};

TEST_P(AbsTest, ComputesAbsoluteValue) {
    int input = GetParam().first;
    int expected = GetParam().second;

    EXPECT_EQ(std::abs(input), expected);
}

INSTANTIATE_TEST_SUITE_P(
    AbsValues,
    AbsTest,
    ::testing::Values(
        std::make_pair(-3, 3),
        std::make_pair(-1, 1),
        std::make_pair(0, 0),
        std::make_pair(2, 2)
    )
);

Tests ausführen

Um die Tests auszuführen, wechseln wir in das Build-Verzeichnis und starten die Tests über ctest:

cd cmake-build-debug
ctest

Test Reports erstellen

In größeren Projekten wird gerne für die Weiterverarbeitung ein Report in HTML oder XML erwartet,
der sich zum Beispiel für den Import in ein Quality Gate Tool wie Sonar Cube eignet.
In Google Test erreicht man dies, in dem man ctest so ausführt:

ctest --output-junit test-report.xml

Übersicht Test Makros

Fazit

Google Test ist ein angenehmes Test-Framework mit einer entspannten Lernkurve.
Die Integration in moderne IDEs wie Jetbrains CLion ist ein weiterer Pluspunkt.
Den gesamten Code findest du hier: https://github.com/jboegeholz/modern_cpp/blob/master/tests/00_google_test.cpp

Weiterführende Links

https://creatronix.de/software-testing-concepts/
https://creatronix.de/wie-tdd-die-welt-rettet-und-deine-nerven-schont/
https://creatronix.de/wie-baue-ich-eine-entwicklungsbegleitende-software-qualitatssicherung-auf/

The post So verwendest du Google Test in deinem C++-Projekt appeared first on Creatronix.

Ich habe aktiv als Entwickler von 2005-2009 Komponenten in C++ implementiert. Hatte dann noch mal einen kurzen Kontakt in der Qualitätssicherung aus der Tester-Perspektive mit der Programmiersprache. Wir haben unter anderen JNA-Wrapper für eine C-Library gebaut.

Ich hatte immer eine gewisse Hassliebe zu der Programmiersprache C++. Einerseits, weil ich wusste, dass es für Performance-orientierte Programme zu dem Zeitpunkt nichts besseres gab. Andererseits habe ich gefühlt oft mehr mit dem Compiler gekämpft, als wirklich echte Probleme zu lösen. Das Potenzial sich in den Fuß zu schießen, war enorm.

Die Unterstützung durch moderne IDEs war zu dem Zeitpunkt auch noch schwierig. Obwohl wir mit dem Visual Studio gearbeitet haben, waren viele Dinge so proprietär, dass heutige unverzichtbare Features wie Code Completion oder auch Hinweise von Lintern nicht immer vollumfänglich funktioniert haben.

Allerdings war das alles vor 2011 und seit dem Sprachstandard C++11 sind extrem viele coole Sachen in C++ passiert. Über ein paar Neuerungen habe ich hier geschrieben:

Das auto keyword

So verwendest du std::array

So verwendest Du den std::vector

Lambdas in C++

Container initialisieren mit std::iota

How to use tuples

Funktionen asynchron ausführen

Einführung in Multithreading

How to use the Eigen library in C++

CMake

Compiler-Optionen für sauberes C++

Wie setze ich die C++ Compiler-Version in CMake

Testing

So verwendest du Google Test in deinem C++-Projekt

The post Modernes C++ appeared first on Creatronix.

Auf meiner Lernreise in die Welt der Robotik ist eines meiner Ziele, mein angestaubtes C++-Wissen aufzubessern. Heute schauen wir uns das Konzept von Lambdas an.

Beispiel sort

Angenommen, wir wollen einen std::vector sortieren, dann können wir das folgendermaßen machen:

std::vector<float> numbers = { -3.5, 1.0, -2.0, -11.0}; 
std::sort(numbers.begin(), numbers.end());

Der Vector wird hier inplace aufsteigend sortiert.

-11.0 < -3.5 < -2.0 < 1.0

Was aber, wenn wir absteigend sortieren wollen? Bis einschließlich C++03 musste dazu eine Komparator-Funktion definiert werden, die via Funktionszeiger an die sort-Funktion übergeben wird

bool sort_descending(const float a, const float b)
{ 
    return a > b; 
} 
std::sort(numbers.begin(), numbers.end(), sort_descending);

Nachteile Funktionszeiger

Diese Funktionen müssen außerhalb der main Funktion und außerhalb von Klassen definiert werden, da nested functions von C++ nicht unterstützt werden und Methoden nicht (einfach) als Funktionszeiger verwendet werden dürfen. “Externe” Funktionen können aber nachteilig für die Wartbarkeit einer Code-Basis sein.

Lambdas for the rescue

Jetzt kommen die Lambdas ins Spiel. Lambdas sind anonyme Funktionen, die keinen Funktionsnamen besitzen.

Beispiel mit sort

Bei einem Lambda-Ausdruck kann der Komparatorcode innerhalb des sort-Funktionsaufrufes definiert werden:

std::sort(numbers.begin(), numbers.end(), [] (const float a, const float b) {return a > b;});

Anatomie eines Lambdas

Hier siehst du den Aufbau eines Lambda-Befehls:

[capture list](parameter) -> return_type { body }

Capture-List

Die Capture List sagt dem Compiler, welche Variablen aus dem umgebenden Kontext (bspw. lokale Variablen in main) in das Lambda übernommen werden sollen.
Wie wir später sehen werden, ist es oft auch eine gute Idee, den this-Zeiger in der Capture-List einzufangen, da das die Lesbarkeit erhöht.

Parameter

Wie bei einer normalen Funktion sind die Parameter die Platzhalter für die Argumente, die an die Funktion übergeben werden sollen und die in der Funktion verwendet werden können.

Return-Type

Der Compiler kann in den meisten Fällen den Rückgabetyp des Lambdas herleiten, deswegen muss er nicht immer explizit angegeben werden.

Funktionsrumpf

Im Rumpf der Funktion können nun sowohl die gecapturerten Variablen, als auch die Parameter verwendet werden.
Der Return-Wert muss zum return-type passen, falls dieser explizit angegeben wurde.

Named Generic Lambdas

Seit C++14 kann ein Lambda-Ausdruck auch einer Variablen zugewiesen werden. Es muss hier das auto keyword verwendet werden:

auto twice = [] (const auto& x) { 
    return 2*x; 
}; 

double ist jetzt ein Lambda-Objekt, das auch innerhalb einer anderen Funktion definiert werden kann.
Aufgerufen wird es nun wie eine herkömmliche Funktion:

std::cout << twice(4);

std::bind vs lambda

Zurück zur Robotik.

std:bind ist eine Möglichkeit in C++, Methoden einer Klasse als callback-Funktionen zu verwenden. Dies wird gerne in ROS-Nodes verwendet, um zum Beispiel Timer-Callbacks zu realisieren. Hier ein Beispiel aus dem sehr guten ROS-Tutorial von Eduard Rennard:

timer = this->create_wall_timer(std::chrono::milliseconds(1000), std::bind(&RobotNewsStationNode::publish_message, this));

Das sieht für das ungeübte Auge etwas krude aus. Das liegt daran, dass Methoden (also Funktionen einer Klasse) keine Function Pointer sein können. Als Alternative können hier auch Lambdas benutzt werden:

timer = this->create_wall_timer(std::chrono::milliseconds(1000), [this] { publish_message(); });

Das wirkt schon deutlich übersichtlicher. Die Capture-List bringt den this-Zeiger in den Scope des Lambdas, deshalb kann im Funktionsrumpf direkt die publish_message Methode aufgerufen werden.

Lambdas mit Parametern

Wenn an den Callback auch Parameter übergeben werden sollen, wird es mit std::bind noch unübersichtlicher, weil hier der Platzhalter für Funktionsargumente _1 benutzt werden muss:

using namespace std::placeholders;
using example_interfaces::msg::String;
subscriber = this->create_subscription("/talker", 10, std::bind(&MyListener::listener_callback, this, _1));

Auch hier kann ein Lambda-Ausdruck wieder etwas Lesbarkeit zurückbringen:

subscriber = this->create_subscription("/talker", 10, [this](const String &msg) { listener_callback(msg);});

The post Lambdas in C++ appeared first on Creatronix.

Wenn man lange mit dynamisch typisierten Sprachen wie Python gearbeitet hat, empfindet man
Sprachen, die eine explizite Typangabe zur Compile-Zeit verlangen, komplizierter und langsamer in der Implementierung.

Aber halt: in C++ hat sich seit C++11 einiges getan.

Wie war es früher?

Vor C++11 musste der Datentyp einer Variablen immer explizit angeben werden:

int age = 42;
double weight = 86.6;
const char* name = "Joern";

Das auto Keyword

auto sagt dem Compiler: “Bestimme den Typ selbst, basierend auf der Initialisierung.”
Das bedeutet aber auch, dass Variablen immer direkt initialisiert werden müssen!

auto age = 42;
auto weight = 86.6;
auto name = "Joern";

Den inferierten Typ können wir mit der Funktion typeid ausgeben lassen:

std::cout << typeid(age).name() << std::endl;
std::cout << typeid(weight).name() << std::endl;
std::cout << typeid(name).name() << std::endl;

Dies gibt Folgendes aus:

i
d
PKc

Kurzer Ausflug – Name Mangling

Name Mangling ist der Vorgang, bei dem der C++-Compiler Funktions- und Klassennamen intern kodiert, um zusätzliche Informationen wie Parameterlisten, Namespaces oder Templates in den Symbolnamen einzubetten. Dadurch können z. B. überladene Funktionen eindeutig unterschieden werden.

Während void foo(int) für den Menschen lesbar bleibt, wird sie im maschinennahen Code z. B. zu _Z3fooi. Dieses Verfahren ist notwendig für den Linker, führt aber zu Symbolnamen, die ohne Demangling schwer lesbar sind.

Außer unter MSVC gibt typeid(new_age).name() den vom Compiler gemangelten Type aus: Um trotzdem den menschenlesbaren Typ angezeigt zu bekommen, kann folgenden Hilfsfunktion benutzt werden:

template<typename T>
void output_type(const T& var) 
{ 
    const char* mangled = typeid(var).name(); 
    int status;
    const std::unique_ptr<char, void(*)(void*)> demangled { 
        abi::__cxa_demangle(mangled, nullptr, nullptr, &status), 
        std::free 
    }; 
    if (status == 0 && demangled) 
        std::cout << "Typ: " << demangled.get() << '\n'; 
    std::cout << "Typ (mangled): " << mangled << '\n'; 
}

Schleifen mit auto

Wenn wir beispielsweise über einen Vector iterieren wollen, musste das bis einschließlich C++03 so gemacht werden.

std::vector<int> v = {1, 2, 3}; 
for (std::vector<int>::iterator it = v.begin(); it != v.end(); ++it) 
{
    std::cout << *it << '\n';
}

Seit C++11 kann das auch viel kürzer geschrieben werden:

for (const auto& value : v){
    std::cout << value << '\n';
}

Es empfiehlt sich hier, const auto& zu verwenden, da sonst jedes Element aus dem Vektor kopiert würde.

auto und const

auto entfernt standardmäßig const- und Referenz-Qualifizierer.
Wenn du sie erhalten willst, musst du sie explizit angeben – z. B. const auto&.

Fazit

Das auto Keyword ist eine sehr nützliche Erweiterung in C++11, die den Code kürzer und lesbarer macht.
Für Umsteiger von Sprachen wie Python ist es eine Erleichterung, da sie nicht mehr ständig an die Typen denken müssen.

The post Das auto keyword – Modernes C++ appeared first on Creatronix.

Nachdem ich mich in den letzten Wochen wieder vermehrt mit modernem C++ beschäftigt habe, möchte ich auch sicherstellen, dass mein Code maximal davon profitiert. Ein Aspekt davon ist es, möglichst sauberes C++ durch den Compiler zu erzwingen. Das geht am besten durch Compiler-Optionen.

Was sind Compiler-Optionen?

Compiler-Optionen oder auch Flags sind unverzichtbare Werkzeuge, um C++-Programme effizient, sicher und standard-konform zu erstellen. Sie ermöglichen die gezielte Steuerung des Kompilierungsprozesses – etwa durch die Auswahl des C++-Standards, die Aktivierung von Optimierungen oder die Kontrolle über Warnungen und Fehler.

Besonders in größeren Projekten helfen Flags typische Programmierfehler frühzeitig zu erkennen und die Codequalität langfristig zu sichern.

Ohne bewusst gesetzte Compiler-Optionen bleiben potenziell gefährliche Probleme oft unbemerkt, was sich negativ auf Wartbarkeit, Portabilität und Laufzeitverhalten auswirken kann.
Nachdem wir in Wie setze ich die C++ Version in CMake schon mal via Compiler-Option die C++-Version gesetzt haben, kümmern wir uns heute um weitere Optionen.

Wie füge ich Compiler-Optionen in CMake hinzu?

Mit dem Kommando add_compile_options kannst Du die Flags setzen:

add_compile_options(-W<option_name>)

Beispiel

add_compile_options(-Wall)

Die Optionen im Detail

Die folgenden Option gelten für GCC und Clang.

-Wall

-Wall heißt nicht „alle Warnungen“, sondern: „Viele sinnvolle Standardwarnungen, die dich vor typischen Fehlern bewahren“
-Wall erkennt zum Beispiel ungenutzte Variablen oder den beliebten Fehler Zuweisung statt Vergleichsoperator

Beispiel unused variable

warning: unused variable 'x' [-Wunused-variable]
       38 |     int x = 42;
          |         ^

Beispiel Zuweisungs- statt Vergleichsoperator

if (x = 5) 
{
    std::cout << x << '\n';
}

warning: suggest parentheses around assignment used as truth value [-Wparentheses]
       39 |     if (x = 5) {
          |         ~~^~~

-Wextra

-Wextra kann zum Beispiel ungenutzte Parameter bei Funktionsaufrufen erkennen:

void unsused_param(std::string name)
{
    std::cout << "unsused_param" << '\n';
}

warning: unused parameter 'name' [-Wunused-parameter]
       35 | void unsused_param(std::string name)
          |                    ~~~~~~~~~~~~^~~~

-Wpedantic

Aktiviert Warnungen für alles, was gegen den offiziellen C++-Standard verstößt.
Selbst wenn es der Compiler akzeptieren würde, wird eine Warnung ausgegeben.

Ein gutes Beispiel sind VLAs:

int len = 3;
int vla[len];  

warning: ISO C++ forbids variable length array 'vla' [-Wvla]
       52 |     int vla[len];
          |         ^~~

-Wconversion

-Wconversion warnt bei impliziten Typumwandlungen, bei denen potenziell Informationen verloren gehen könnten – insbesondere bei „narrowing conversions“.

int z = 1.2;
std::cout << z << '\n';

warning: conversion from 'double' to 'int' changes value from '1.2e+0' to '1' [-Wfloat-conversion]
       49 |     int z = 1.2;
          |             ^~~

-Werror

Macht aus Warnungen Fehler und führt zum Build-Abbruch. Das ist nicht immer gewollt, deswegen kann man es beispielsweise nur für den Release-Build aktivieren:

if(CMAKE_BUILD_TYPE STREQUAL "Release")
    add_compile_options(-Werror)
endif()

Beim Aufruf von CMake muss dann das folgende Flag an CMake übergeben werden:

-DCMAKE_BUILD_TYPE=Release

tl;dr;

Am besten setzt ihr zum Ausprobieren -Wall, -Wextra und -Wpedantic.

Bonus

Unter Windows heißen die Option anders. Deswegen ist es sinnvoll eine Fallunterscheidung einzubauen:

if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    message(STATUS "Compiler Clang")
    add_compile_options(-Wall -Wextra -Wpedantic)

elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
    message(STATUS "Compiler GCC")
    add_compile_options(-Wall -Wextra -Wpedantic)

elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
    message(STATUS "Compiler MSVC")
    add_compile_options(/W4 /WX)
endif()

The post Compiler-Optionen für sauberes C++ appeared first on Creatronix.

Working with matrices and vectors in C++ can be a bit cumbersome. The Eigen library is a C++ template library for linear algebra: matrices, vectors, numerical solvers, and related algorithms. It is used in many scientific and engineering applications. Eigen is versatile, efficient, and easy to use. It supports all matrix sizes, from small fixed-size matrices to arbitrarily large dense matrices, and even sparse matrices.

Installation

Eigen is a header-only library. You can download it from the official website and include it in your project.
Under Windows, you can use nuget to install Eigen. Just search for Eigen3 in the nuget package manager and install it.
Under Linux, you can install Eigen with the package manager:

sudo apt-get install libeigen3-dev

Mac OS

brew install eigen

Setup

set(CMAKE_CXX_STANDARD 14)
include_directories(/opt/homebrew/opt/eigen/include/eigen3)

Usage

Here is a simple example of how to use Eigen in your C++ code:

#include <iostream>
#include <Eigen/Dense>

int main()
{
    Eigen::MatrixXd m(2, 2);
    m(0, 0) = 3;
    m(1, 0) = 2.5;
    m(0, 1) = -1;
    m(1, 1) = 4.0;
    std::cout << m << std::endl;
}

The matrix m is a 2×2 matrix.
The d in the MatrixXd stands for double. You can also use MatrixXf for float or MatrixXi for int.
Dynamic sizes are indicated by the X in the type name.
Fixed-size matrices are defined with the number of rows and columns like Matrix2d for a 2×2 matrix.

You can access the elements of the matrix with the () operator.

Operands

An interesting feature of Eigen is the operator overloading.
You can use the standard arithmetic operators like +, -, *, / with Eigen matrices and vectors.

Initialization

To initialize a matrix you can also use the << operator, which provides a more concise way to initialize a matrix:

Eigen::MatrixXd m2(2, 2);
m2 << 1, 2,
      3, 4;

Transpose

You can transpose a matrix with the transpose() method:

Eigen::MatrixXd m3(2, 3);
m3 << 1, 2, 3, 
     4, 5, 6;
std::cout << "Here is the matrix m:" << std::endl << m3 << std::endl;
std::cout << "Here is the matrix m^T:" << std::endl << m3.transpose() << std::endl;

Determinant

You can calculate the determinant of a matrix with the determinant() method:

Eigen::MatrixXd m5(2, 2);
m5 << 1, 2,
      3, 4;
std::cout << "Here is the matrix m:" << std::endl << m5 << std::endl;
std::cout << "Here is the determinant of m:" << std::endl << m5.determinant() << std::endl;

Inverse

You can calculate the inverse of a matrix with the inverse() method:

Eigen::MatrixXd m4(2, 2);
m4 << 1, 2,
      3, 4;
std::cout << "Here is the matrix m:" << std::endl << m4 << std::endl;
std::cout << "Here is the inverse of m:" << std::endl << m4.inverse() << std::endl;

Links

https://libeigen.gitlab.io/

The post How to use the Eigen library in C++ appeared first on Creatronix.

Python supports the concept of multiple return values since its first version.
C++ introduced the concept in C++11. Let’s have a look how it works:

How to use it

1. You need to include the header include <tuple>
2. You have to declare return parameter of your function e.g. std::tuple<int, int>
3. You use the function make_tuple: return std::make_tuple(x, y);
4. On the caller side you need to tie the return values to local variables e.g. std::tie(x_pos, y_pos)

That’s all!

Example Code

#include 
#include 
#include 

std::tuple<double, double> calculate_mean_and_variance(std::vector measurements)
{
    double sum = 0.0;
    for (double num : measurements) {
        sum += num;
    }
    double _mean = sum / measurements.size();

    double sq_sum = 0.0;
    for (double num : measurements) {
        sq_sum += (num - _mean) * (num - _mean);
    }

    double variance = sq_sum / measurements.size();

    return std::make_tuple(_mean, variance);
}

int main()
{
    std::vector measurements = { 1, 2, 3, 4 };
    double mean, variance;
    std::tie(mean, variance) = calculate_mean_and_variance(measurements);
    std::cout << mean << ", " << variance << std::endl;
    return 0;
}

The post Modern C++: How to use tuples appeared first on Creatronix.

Im Rahmen meines Udacity Nanodegree Robotics Software Engineer musste ich mit C++17 arbeiten, da ROS Noetic Ninjemys Sprachfeature
von C++17 verwendet. Nun wollte ich wissen, wie ich die C++-Version in CMake setze.

Top Level Cmake-Datei

In der Top-Level CMake-Datei setze ich die C++-Version folgendermaßen:

set(CMAKE_CXX_STANDARD 17) 
set(CMAKE_CXX_STANDARD_REQUIRED ON)

Bei einigen Compilern wie dem clang unter macos bekommt ihr nicht automatisch alle neuen Sprachfeatures, ihr braucht dann noch das compiler flag -stdlib=libc++

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
    message(STATUS "Using Clang - setting -stdlib=libc++")
    add_compile_options(-stdlib=libc++)
    add_link_options(-stdlib=libc++)
endif()

The post Wie setze ich die C++ Compiler-Version in CMake appeared first on Creatronix.