C++ Academy · Leçon

Schémas de gestion des erreurs

Composer optional et expected

Schémas de gestion des erreurs est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Deux outils, un seul objectif

std::optional et std::expected remplacent tous deux les sentinelles sujettes aux erreurs. Cette leçon présente des façons de les combiner et de les composer proprement.

Retour anticipé si empty

Un schéma simple et lisible : vérifiez l'optionnel et quittez immédiatement s'il est empty avant de poursuivre.

#include <iostream>
#include <optional>
std::optional<int> parse(bool ok) { return ok ? std::optional<int>(5) : std::nullopt; }
int main() {
    auto v = parse(true);
    if (!v) { std::cout << "no value\n"; return 0; }
    std::cout << *v + 1 << "\n";
}

D'optionnel à expected

Convertissez un optionnel manquant en erreur décrite lorsque l'appelant a besoin d'en connaître la raison.

#include <expected>
#include <optional>
#include <string>
std::expected<int, std::string> require(std::optional<int> o) {
    if (o) return *o;
    return std::unexpected("value missing");
}
int main() {}

Chaînage avec value_or

Lorsque plusieurs recherches alimentent un même résultat, value_or vous permet de fournir des valeurs par défaut directement, sans conditions imbriquées.

#include <iostream>
#include <optional>
int setting(std::optional<int> user, int fallback) {
    return user.value_or(fallback);
}
int main() {
    std::cout << setting(std::nullopt, 42) << "\n";
}

Propagation des erreurs vers l'appelant

Avec std::expected, une fonction peut examiner un sous-appel et transmettre son erreur sans la modifier, formant ainsi une chaîne de propagation des erreurs.

#include <expected>
#include <string>
using R = std::expected<int, std::string>;
R step1(bool ok) { return ok ? R(2) : R(std::unexpected("step1 failed")); }
R run(bool ok) {
    auto r = step1(ok);
    if (!r) return std::unexpected(r.error());
    return *r * 10;
}
int main() {}

and_then monadique

En C++23, and_then enchaîne des opérations qui renvoient chacune un optionnel ou un expected, en s'arrêtant au premier échec, sans cascade manuelle de conditions.

transform pour le mappage

transform applique une fonction ordinaire à la valeur obtenue en cas de réussite et laisse les erreurs ou l'absence inchangées, en mappant uniquement le chemin nominal.

or_else pour la récupération

or_else exécute une solution de repli qui peut fournir une valeur de remplacement ou une autre erreur lorsque la valeur d'origine est absente ou que l'opération a échoué.

Choisir entre les deux

Utilisez optionnel lorsque l'absence ne nécessite aucune explication, par exemple en cas d'échec d'une recherche dans le cache. Utilisez attendu lorsque l'appelant doit distinguer les raisons de l'échec, comme une erreur d'analyse syntaxique ou de permission.

Éviter les sentinelles mixtes

Ne mélangez pas les anciens codes d'erreur avec optional/expected dans une même API. Choisissez une stratégie cohérente afin que les appelants traitent les échecs uniformément.

Conserver des erreurs typées

Préférez une énumération ou une petite structure pour le type d'erreur plutôt que de simples chaînes lorsque les échecs sont vérifiés par programme ; les chaînes conviennent mieux aux messages destinés aux utilisateurs.

Vérification rapide

Vérifiez votre compréhension des schémas de gestion des erreurs.

Récapitulatif

Vous avez appris les schémas de gestion des erreurs :

Un retour anticipé en cas d'absence ou d'erreur garde le code à plat.
Convertissez un optionnel en expected lorsqu'une raison est nécessaire.
Composez avec and_then, transform et or_else (C++23).
Restez cohérent ; évitez de mélanger les sentinelles avec optional/expected.

Questions Fréquemment Posées

La leçon « Schémas de gestion des erreurs » est-elle gratuite ?

Oui — le texte complet de « Schémas de gestion des erreurs » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Schémas de gestion des erreurs » ?

Composer optional et expected Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Schémas de gestion des erreurs » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à C++ Academy