C++17 : quoi de neuf ? Guide complet avec exemples pour les pros

Qu'a apporté C++17 ? Analyse des principales nouveautés de la norme

Si vous programmez en C++ et souhaitez rester dans le courant dominant, C++17 est la version à maîtriser dès maintenant. Il est sorti en 2017, mais de nombreux projets « stagnent » encore sur C++14 ou même C++11, craignant de passer à la nouvelle norme. À tort.

Dans cet article, nous analyserons les nouvelles fonctionnalités de C++17 avec des exemples concrets. Vous apprendrez à simplifier le code, à éliminer les vérifications superflues et à rendre les programmes plus rapides. Nous ne listerons pas les 105 changements, seulement ce qui vous sera vraiment utile dans votre travail.

1. Liaisons structurées (Structured Bindings) — décomposition en un instant

L'une des fonctionnalités C++17 les plus pratiques est la liaison structurée. Avant, pour décomposer un tuple ou une paire, il fallait utiliser std::tie ou accéder par indices. Maintenant, c'est bien plus élégant.

Exemple : retourner plusieurs valeurs depuis une fonction

#include <iostream>\n#include <tuple>\n#include <string>\n\nstd::tuple<int, std::string, double> getData() {\n    return {42, "Réponse", 3.14};\n}\n\nint main() {\n    // C++17 : une seule ligne au lieu de std::tie\n    auto [id, name, value] = getData();\n    std::cout << name << ": " << id << " (" << value << ")\\n";\n    return 0;\n}

Qu'est-ce qui a changé ? Avant, il fallait déclarer les variables séparément, puis appeler std::tie. Maintenant, auto [a, b, c] fait tout le travail à votre place.

Les liaisons structurées fonctionnent non seulement avec les tuples, mais aussi avec les tableaux et toute structure ayant des champs publics. C'est l'une des innovations de C++17 qui rend le code plus propre et plus lisible.

2. std::optional — se débarrasser des valeurs « magiques »

Combien de fois avez-vous vu du code où une fonction retourne -1 ou nullptr pour indiquer une erreur ? Ou pire, un booléen et un résultat par référence ? std::optional<T> résout ce problème une fois pour toutes.

Exemple : recherche sécurisée dans un conteneur

#include <iostream>\n#include <optional>\n#include <map>\n#include <string>\n\nstd::optional<int> findValue(const std::map<std::string, int>& m, const std::string& key) {\n    auto it = m.find(key);\n    if (it != m.end()) {\n        return it->second;  // valeur trouvée\n    }\n    return std::nullopt;    // valeur non trouvée\n}\n\nint main() {\n    std::map<std::string, int> ages = {{"Alice", 30}, {"Bob", 25}};\n    \n    auto result = findValue(ages, "Charlie");\n    if (result) {\n        std::cout << "Trouvé : " << *result << "\\n";\n    } else {\n        std::cout << "Clé non trouvée\\n";\n    }\n    \n    // Ou utilisez value_or pour une valeur par défaut\n    int age = result.value_or(0);\n    return 0;\n}

std::optional est un conteneur qui peut contenir une valeur ou être vide. Vous le vérifiez avec if (opt) et accédez à la valeur via *opt ou opt.value(). C'est bien plus sûr que les codes d'erreur « conventionnels ».

3. if constexpr — des templates sans maux de tête

Les nouvelles fonctionnalités de C++17 pour la métaprogrammation sont un véritable cadeau. if constexpr permet une compilation conditionnelle dans les templates sans acrobaties SFINAE.

Exemple : fonction universelle pour différents types

#include <iostream>\n#include <type_traits>\n#include <string>\n\ntemplate <typename T>\nvoid printInfo(const T& value) {\n    if constexpr (std::is_integral_v<T>) {\n        std::cout << "Nombre entier : " << value << "\\n";\n    } else if constexpr (std::is_floating_point_v<T>) {\n        std::cout << "Nombre à virgule flottante :