Fonctionnel vs POO en C++ : que choisir en 2025 ?

Introduction : pourquoi le débat POO contre approche fonctionnelle ne s'éteint-il pas ?

Si vous vous êtes déjà demandé quel style de programmation en C++ choisir pour un nouveau projet, vous n'êtes pas seul. Le débat entre la programmation fonctionnelle et l'approche orientée objet en C++ dure depuis des décennies. D'un côté, la POO classique enseignée à l'université. De l'autre, les techniques fonctionnelles modernes apportées par les normes C++11, C++14, C++17 et C++20.

Sur le site pythonlib.ru, nous discutons souvent de décisions architecturales, et aujourd'hui il est temps de clarifier cette question une fois pour toutes. Quel style est le plus rapide ? Lequel est le plus facile à maintenir ? Et surtout, peut-on les combiner ?

Dans cet article, nous ne défendrons pas fanatiquement un paradigme. Au lieu de cela, nous analyserons des exemples de code réels, montrerons les avantages et les inconvénients de chaque approche et donnerons des recommandations pratiques. C'est parti !

Bref aperçu des paradigmes en C++

Avant d'approfondir, rafraîchissons-nous rapidement la mémoire sur le sujet.

Programmation orientée objet (POO)

La POO en C++ repose sur trois piliers : l'encapsulation, l'héritage et le polymorphisme. Vous créez des classes qui regroupent les données et les méthodes pour les traiter. C'est l'approche classique qui a dominé les années 90 et 2000.

class Animal {\npublic:\n    virtual void speak() const = 0;\n    virtual ~Animal() = default;\n};\n\nclass Dog : public Animal {\npublic:\n    void speak() const override {\n        std::cout << "Woof!" << std::endl;\n    }\n};\n\nclass Cat : public Animal {\npublic:\n    void speak() const override {\n        std::cout << "Meow!" << std::endl;\n    }\n};\n\nvoid makeSound(const Animal& animal) {\n    animal.speak();\n}\n

Programmation fonctionnelle (PF)

L'approche fonctionnelle en C++ n'est pas du Haskell pur, mais plutôt l'utilisation d'idées de la PF dans le cadre d'un langage impératif. Les éléments clés sont : les fonctions lambda, l'immuabilité des données, les fonctions d'ordre supérieur et la composition.

std::vector<int> numbers = {1, 2, 3, 4, 5};\n\n// Style fonctionnel : filtrage et transformation\nauto result = numbers\n    | std::views::filter([](int n) { return n % 2 == 0; })\n    | std::views::transform([](int n) { return n * n; });\n\nfor (int n : result) {\n    std::cout << n << " ";  // Affichage : 4 16\n}\n

Comparaison pratique : trois tâches typiques

Prenons trois tâches réelles auxquelles un développeur C++ est confronté et voyons comment la POO et la PF les résolvent.

Tâche 1 : Traitement d'une collection de données

Condition : Une liste de commandes, il faut filtrer les chères (prix > 1000), trier par date et afficher le top 5.

Style POO :

class OrderProcessor {\npublic:\n    void addOrder(Order order) { orders_.push_back(std::move(order)); }\n    \n    std::vector<Order> getTopExpensiveRecent(int count) const {\n        auto filtered = orders_;\n        filtered.erase(\n            std::remove_if(filtered.begin(), filtered.end(),\n                           [](const Order& o) { return o.price <= 1000; }),\n            filtered.end());\n        \n        std::sort(filtered.begin(), filtered.end(),\n                  [](const Order& a, const Order& b) {\n                      return a.date > b.date;\n                  });\n        \n        if (filtered.size() > count) {\n            filtered.resize(count);\n        }\n        return filtered;\n    }\n    \nprivate:\n    std::vector<Order> orders_;\n};\n

Style fonctionnel :

auto getTopExpensiveRecent(const std::vector<Order>& orders, int count) {\n    return orders\n        | std::views::filter([](const Order& o) { return o.price >