Technische Details in C++ abstrahieren, um die Lernkurve der Sprache zu verringern.

Kürzlich stieß ich auf einen LinkedIn-Beitrag, der die Reaktion eines C++-Entwicklers zeigte, als er zum ersten Mal sah, wie Arrays in Python sortiert werden. Wenig überraschend war die Einfachheit des Python-Ansatzes für ihn verblüffend.

arr=[64,12,22,55,44]
bubble_sort(arr)
print("Sorted Array:",arr)

Solche Beobachtungen sagen weniger über die Sprache selbst aus als über die Abstraktionen, die Bibliotheken und Frameworks bereitstellen. Eine vergleichbare Einfachheit lässt sich auch in C++ erreichen, indem die Komplexität hinter einem eigenen oder einem bestehenden Framework verborgen wird.

Anstatt Code wie diesen zu verwenden:

 std::vector<int> vec = {64, 12, 22, 55,44};
 std::sort(vec.begin(), vec.end());
 std::cout << "Sorted vector: ";
 for(const int& num : vec) {
        std::cout << num << " ";
  }
  std::cout << std::endl;

Mit einer geeigneten C++-Bibliothek kann der Code stattdessen so aussehen:

auto arr[] = { 64, 12,22,55,44 }; 
boost::sort(arr);
boost::print(std::cout, arr);

Selbst wenn eine solche Funktion in keiner bekannten C++-Bibliothek vorhanden ist, setzen viele Projekte auf interne Bibliotheken, die technische Komplexität abstrahieren und Aufgaben unabhängig von der Programmiersprache vereinfachen.

C++ gilt häufig als komplex, weil die Sprache für viele alltägliche Aufgaben keine sofort nutzbaren Komfortfunktionen bereitstellt. Bei der Standard Template Library (STL) müssen Entwickler beispielsweise direkt mit Iteratoren arbeiten. Das kann den Code durch die häufige Verwendung von .begin() und .end() -Funktionen unnötig verkomplizieren.

#include <iostream>
#include <vector>
#include <algorithm> // for std::sort and std::merge
#include <iterator>  // for std::back_inserter

int main() {
    std::vector<int> vec1 = {1, 4, 7, 10};
    std::vector<int> vec2 = {2, 5, 8, 11};
    std::vector<int> vec3 = {3, 6, 9, 12};

    // Merging vec1 and vec2 into vecMerged
    std::vector<int> vecMerged;
    std::merge(vec1.begin(), vec1.end(), vec2.begin(), vec2.end(), std::back_inserter(vecMerged));

    // Merging vecMerged with vec3
    std::vector<int> vecFinal;
    std::merge(vecMerged.begin(), vecMerged.end(), vec3.begin(), vec3.end(), std::back_inserter(vecFinal));

    // Sorting vecFinal
    std::sort(vecFinal.begin(), vecFinal.end());

    // Printing the sorted merged vector
    std::cout << "Sorted merged vector: ";
    for (auto it = vecFinal.begin(); it != vecFinal.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

Mit den Möglichkeiten von C++ lässt sich dennoch sauberer und leicht verständlicher Code schreiben, der dem moderner Programmiersprachen in nichts nachsteht. Dafür muss man die Kunst beherrschen, Komplexität mithilfe geeigneter Bibliotheken und eines robusten internen technischen Frameworks vor den Entwicklern zu verbergen. Das Team, das für diese technische Schicht verantwortlich ist, spielt eine entscheidende Rolle dabei, den Code lesbar und wartbar zu halten.

Fazit

Abstraktionen, die technische Frameworks in C++ bereitstellen, können die Entwicklung erheblich vereinfachen, indem sie High-Level-Schnittstellen für häufige Aufgaben anbieten. Dadurch müssen Entwickler die komplexen Details der Sprache und ihrer zugrunde liegenden Implementierung weniger genau kennen und können leichter effizienten, lesbaren und wartbaren Code schreiben. Mit solchen Abstraktionen können sie sich auf die eigentlichen Probleme konzentrieren, anstatt sich mit Low-Level-Details beschäftigen zu müssen.