Utilisation de std :: apply sur std :: attendu en C++23

Lina Fontaine
Mercredi 18 septembre 2024 à 19:23:18
C++

Rationalisation de la gestion des erreurs en C++23

La gestion efficace des erreurs et la gestion des valeurs de retour sont essentielles dans le développement C++ actuel. La méthode typique de travail avec des fonctions qui renvoient des types {std::expected} inclut de nombreuses vérifications et du code de gestion des erreurs, ce qui peut compliquer la logique et rendre le code plus difficile à maintenir.

Cet article étudie l'utilisation d'une méthode plus sophistiquée et générale pour simplifier la gestion des erreurs. Afin de réduire le code passe-partout et d'améliorer la lisibilité, nous étudierons la construction d'une méthode `magic_apply` qui agrège les résultats de nombreuses valeurs {std::expected} et les transmet à une autre fonction.

Commande Description
std::expected Type de modèle utilisé en C++ pour la gestion des erreurs et capable de stocker à la fois des valeurs et des erreurs.
std::unexpected Lorsqu'il est utilisé avec std::expected, représente une valeur d'erreur inattendue.
template<typename...> Décrit un modèle variadique avec une quantité infinie d'arguments de modèle qu'il peut accepter.
decltype Utilisé dans la programmation de modèles, notamment pour connaître le type d'expression.
args.value() Si un objet std::expected a une valeur, accède à la valeur qu'il contient.
args.has_value() Vérifie si une valeur est présente dans un objet std::expected.
(... && args.has_value()) Pour déterminer si chaque objet std::expected a des valeurs, pliez l'expression.
func(args.value()...) Utilise les valeurs de l'objet std::expected pour appeler la fonction méthode.
return unexpected<Err>(args.error()...) Renvoie une erreur inattendue contenant les erreurs des objets std::expected.

Gestion efficace des erreurs à l'aide de modèles de variables

Le type est utilisé dans les scripts pour faciliter la gestion des erreurs en C++23. L'objectif principal est de développer une fonction générique appelée qui peut transmettre la sortie de plusieurs valeurs à une autre fonction. En procédant ainsi, la fastidieuse vérification des erreurs qui est généralement nécessaire lorsque l'on travaille avec de nombreux std::expected les valeurs sont réduites. est assez flexible car cela peut prendre n'importe quel nombre de paramètres en utilisant des modèles variadiques. Avant d'appeler la fonction avec le contenu de n'importe quel objet, la logique fondamentale de magic_apply emploie une expression de pli, , pour être sûr que tout les objets ont des valeurs valides.

Cette idée est illustrée dans le premier exemple de script en utilisant des types simples tels que et . Il définit un fonction qui effectue un calcul de base, et getA et fonctions qui renvoient genres. Si les deux valeurs de et getB sont légitimes, nous pouvons appeler en utilisant ; sinon, l'erreur se propage. En réduisant le code passe-partout, cette méthode améliore la lisibilité et la maintenabilité. Une idée similaire est présentée dans le deuxième scénario, mais pour souligner la polyvalence de l'approche, types et lambda functions sont utilisés.

Réduire la complexité dans la gestion des erreurs C++ avec `std::expected}

Script C++23 utilisant des modèles variadiques

#include <expected>
#include <string>
#include <iostream>
#include <tuple>

using namespace std;

template<typename Func, typename... Args, typename Err>
auto magic_apply(Func func, const expected<Args, Err>&... args) -> expected<decltype(func(args.value()...)), Err> {
    if ((... && args.has_value())) {
        return func(args.value()...);
    } else {
        return unexpected<Err>(args.error()...);
    }
}

expected<int, string> getA(int x) {
    if (x > 0) return x;
    return unexpected<string>("Error in getA");
}

expected<double, string> getB(double y) {
    if (y > 0) return y;
    return unexpected<string>("Error in getB");
}

double compute_all(int a, double b) {
    return a + b;
}

int main() {
    auto result = magic_apply(compute_all, getA(10), getB(20.5));
    if (result) {
        cout << "Result: " << result.value() << endl;
    } else {
        cout << "Error: " << result.error() << endl;
    }
    return 0;
}

Combinaison de différentes valeurs C++23 des résultats {std::expected}

Script C++23 utilisant les fonctions Lambda

#include <expected>
#include <string>
#include <iostream>

using namespace std;

template<typename Func, typename... Args, typename Err>
auto magic_apply(Func func, const expected<Args, Err>&... args) -> expected<decltype(func(args.value()...)), Err> {
    bool all_valid = (args.has_value() && ...);
    if (all_valid) {
        return func(args.value()...);
    } else {
        return unexpected<Err>(args.error()...);
    }
}

expected<string, string> getA(bool flag) {
    if (flag) return "SuccessA";
    return unexpected<string>("Failed A");
}

expected<string, string> getB(bool flag) {
    if (flag) return "SuccessB";
    return unexpected<string>("Failed B");
}

string compute_all(const string& a, const string& b) {
    return a + " and " + b;
}

int main() {
    auto result = magic_apply(compute_all, getA(true), getB(true));
    if (result) {
        cout << "Result: " << result.value() << endl;
    } else {
        cout << "Error: " << result.error() << endl;
    }
    return 0;
}

Améliorer la gestion des erreurs C++ avec des modèles variadiques

La capacité de Améliorer considérablement la gestion des erreurs dans les systèmes complexes est un autre avantage crucial de son utilisation en C++. Combiner de manière transparente les résultats de nombreuses actions asynchrones est essentiel dans les situations où elles donnent des résultats. genres. En plus de simplifier le code, cette méthode garantit une gestion efficace des erreurs. Des fonctions plus polyvalentes et génériques peuvent être créées en combinant un nombre arbitraire de valeurs avec variadic templates.

La polyvalence de lui permet d'être utilisé avec des fonctions qui acceptent une variété de types d'arguments. La mise en œuvre est encore plus simple en utilisant , qui déduit automatiquement le type de retour de l'appel de fonction combiné. De plus, cette technique peut être étendue pour gérer des tâches plus complexes, notamment la fusion valeurs avec d’autres types d’erreurs ou en modifiant les valeurs avant de les envoyer à la fonction. En raison de son adaptabilité, le modèle peut être utilisé pour un large éventail de tâches, depuis des calculs simples jusqu'à des opérations complexes.

Questions fréquemment posées sur les modèles variadiques et std::expected

  1. Qu'est-ce que ?
  2. Il s'agit d'un type de modèle C++ qui peut contenir une erreur ou une valeur valide et est utilisé pour la gestion des erreurs.
  3. Comment travail?
  4. Il élimine le besoin de contrôles d'erreurs répétés en combinant les résultats de nombreux valeurs et les transmettre à une fonction.
  5. Que sont les modèles variadiques ?
  6. Les modèles variables offrent une grande liberté dans la conception des fonctions en permettant aux fonctions d'accepter un nombre arbitraire de paramètres.
  7. Pourquoi utiliser dans ?
  8. En utilisant les valeurs du objets pour déterminer automatiquement le type de retour de la fonction appelée.
  9. Est capable de gérer différents types d’erreurs ?
  10. Oui, il peut être fait fonctionner avec valeurs ayant différents types d’erreurs avec quelques ajustements.
  11. Quels sont les avantages de l'utilisation offre?
  12. Lors du traitement des erreurs, il offre une approche plus expressive et plus propre qu'avec des techniques plus conventionnelles comme les exceptions ou les codes retour.
  13. Est une partie de ?
  14. En plus de , représente en fait une valeur incorrecte.
  15. Les actions asynchrones peuvent-elles être utilisées avec ?
  16. Il est en effet adaptable pour gérer valeurs renvoyées par les opérations asynchrones.
  17. Qu'est-ce qu'une expression de pli ?
  18. Ici, la fonctionnalité en C++ appelée expression de repli est utilisée pour vérifier si tout les objets contiennent des valeurs valides de manière simple.

En C++23, l'implémentation d'une fonction générique pour gérer plusieurs valeurs std::expected améliore considérablement la lisibilité du code et simplifie grandement la gestion des erreurs. La fonction magic_apply réduit le code passe-partout et améliore la maintenabilité en utilisant des modèles variadiques pour garantir que toutes les valeurs anticipées sont correctes avant le traitement. Cette méthode offre une solution flexible qui peut être appliquée à différentes situations et donne à la programmation C++ moderne un moyen plus propre et plus efficace de gérer les échecs.