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

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

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

1. Qu'est-ce que std::expected?
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 magic_apply travail?
4. Il élimine le besoin de contrôles d'erreurs répétés en combinant les résultats de nombreux std::expected 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 decltype dans magic_apply?
8. En utilisant les valeurs du std::expected objets pour déterminer automatiquement le type de retour de la fonction appelée.
9. Est magic_apply capable de gérer différents types d’erreurs ?
10. Oui, il peut être fait fonctionner avec std::expected valeurs ayant différents types d’erreurs avec quelques ajustements.
11. Quels sont les avantages de l'utilisation std::expected 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 std::unexpected une partie de std::expected?
14. En plus de std::expected, std::unexpected représente en fait une valeur incorrecte.
15. Les actions asynchrones peuvent-elles être utilisées avec magic_apply?
16. Il est en effet adaptable pour gérer std::expected 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 std::expected les objets contiennent des valeurs valides de manière simple.

Conclusion :

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.