Abstraire les détails des couches techniques en C++ pour adoucir la courbe d’apprentissage du langage

Récemment, je suis tombé sur un post LinkedIn montrant la réaction d’un développeur C++ découvrant pour la première fois comment on trie un tableau en Python. Sans surprise, la simplicité de l’approche Python a été un choc.

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

Ce genre d’observation tient moins au langage lui-même qu’aux abstractions fournies par les bibliothèques et les frameworks. Nous pouvons atteindre une simplicité similaire en C++ en masquant la complexité derrière notre propre framework ou un framework existant.

Au lieu d’utiliser du code comme celui-ci :

 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;

Nous pouvons utiliser une bibliothèque C++ appropriée et obtenir du code comme celui-ci :

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

Même si une telle facilité n’existe pas dans une bibliothèque C++ bien connue, de nombreux projets s’appuient sur des bibliothèques internes qui abstraient les complexités techniques, facilitant les tâches quel que soit le langage de programmation.

Le C++ est souvent considéré comme complexe parce qu’il ne fournit pas de facilités prêtes à l’emploi pour les tâches courantes. Par exemple, avec la Standard Template Library (STL), les développeurs doivent travailler directement avec les itérateurs, ce qui peut compliquer le code en raison de l’usage fréquent des fonctions .begin() et .end() functions.

#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;
}

Cependant, grâce aux capacités du C++, nous pouvons obtenir un code propre et facile à comprendre, comparable à celui de n’importe quel langage de programmation moderne. Pour cela, il faut maîtriser l’art de masquer la complexité aux développeurs grâce à des bibliothèques appropriées et à un framework technique interne robuste. L’équipe responsable de cette couche technique joue un rôle crucial pour garder le code lisible et maintenable.

Conclusion

Les abstractions fournies par les frameworks techniques en C++ peuvent simplifier considérablement le développement en offrant des interfaces de haut niveau pour les tâches courantes. Cela réduit le besoin de comprendre les détails complexes du langage et de son implémentation sous-jacente, facilitant l’écriture d’un code efficace, lisible et maintenable. En exploitant ces abstractions, les développeurs peuvent se concentrer sur la résolution des problèmes réels plutôt que sur les détails de bas niveau.