Clean Code en C++ : principes et exemples pratiques

Introduction : pourquoi le code propre est important en C++

C++ est un langage puissant et flexible qui permet d'écrire à la fois du code système très performant et des solutions applicatives complexes. Cependant, cette flexibilité se transforme souvent en chaos : les fonctions surchargées, les conversions implicites, la gestion manuelle de la mémoire et les macros peuvent transformer un projet en « marécage » en quelques mois. Le concept de Clean Code (code propre), popularisé par Robert Martin, s'applique pleinement au C++, mais en tenant compte des spécificités du langage.

Dans cet article, nous analyserons les principes clés du code propre en C++ et montrerons leur application sur des exemples concrets. Vous apprendrez à écrire un code facile à lire, à tester et à maintenir.

1. Nommage et structure : la base de la lisibilité

1.1. Noms significatifs pour les variables et les fonctions

La première règle du code propre est que le nom doit révéler l'intention. En C++, c'est particulièrement important en raison de la présence de surcharges et de templates.

Mauvais exemple :

int d; // elapsed time in days\nvoid proc(int a, int b); // que sont a et b ?

Bon exemple :

int elapsedTimeInDays;\nvoid processData(const std::vector<int>& inputData, int maxIterations);

1.2. Classes et espaces de noms

Utilisez les espaces de noms pour le regroupement logique. Évitez les variables globales — c'est un anti-patron.

namespace network {\n    class TcpConnection {\n    public:\n        void connect(const std::string& host, int port);\n        void send(const std::vector<char>& data);\n    private:\n        int socket_;\n    };\n} // namespace network

2. Fonctions : petites et avec une seule responsabilité

2.1. Principe de responsabilité unique (SRP)

Une fonction ne doit faire qu'une seule chose. Si une fonction fait plus d'une action, divisez-la.

Mauvais exemple :

void processOrder(Order& order) {\n    // validation\n    if (order.total < 0) throw std::invalid_argument("Negative total");\n    // sauvegarde en BDD\n    database.save(order);\n    // envoi d'email\n    emailService.send(order.customerEmail, "Order confirmed");\n}

Bon exemple :

bool validateOrder(const Order& order);\nvoid saveOrderToDatabase(const Order& order);\nvoid sendConfirmationEmail(const Order& order);\n\nvoid processOrder(Order& order) {\n    if (!validateOrder(order)) return;\n    saveOrderToDatabase(order);\n    sendConfirmationEmail(order);\n}

2.2. Évitez les effets de bord

Une fonction ne doit pas modifier l'état global sans nécessité explicite. Utilisez des références constantes et retournez des valeurs, plutôt que de modifier les arguments.

// Mauvais : modifie le vecteur d'entrée\nvoid addPrefix(std::vector<std::string>& words, const std::string& prefix) {\n    for (auto& word : words) {\n        word = prefix + word;\n    }\n}\n\n// Bon : retourne un nouveau vecteur\nstd::vector<std::string> addPrefix(const std::vector<std::string>& words, const std::string& prefix) {\n    std::vector<std::string> result;\n    result.reserve(words.size());\n    for (const auto& word : words) {\n        result.push_back(prefix + word);\n    }\n    return result;\n}

3. Gestion de la mémoire et RAII

3.1. Utilisez les pointeurs intelligents

En C++ moderne (C++11 et versions ultérieures), la gestion manuelle de la mémoire via new/delete est considérée comme obsolète. Utilisez std::unique_ptr et std::shared_ptr.

// Mauvais : fuite mémoire possible\nvoid process() {\n    Resource* res = new Resource();\n    // ... si une exception survient ici, la mémoire fuit\n    delete res;\n}\n\n// Bon : libération automatique\nvoid process() {\n    a