Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::nullopt — exprimer explicitement l’absence de valeur

Utilisez `std::nullopt` pour renvoyer ou vider un `std::optional` sans confondre un résultat absent avec une valeur valide telle que zéro.

Version : ISO C++23; implementation support may vary

Syntaxe

#include <optional>

std::optional<int> no_result() {
    return std::nullopt;
}

void clear(std::optional<int>& result) {
    result = std::nullopt;
}

bool is_empty(const std::optional<int>& result) {
    return result == std::nullopt;
}

std::nullopt est une constante inline constexpr de type std::nullopt_t, définie dans <optional> et disponible depuis C++17. Le constructeur qui accepte ce marqueur crée un std::optional<T> vide sans construire d’objet T. Écrivez return std::nullopt; si une fonction renvoie un std::optional<T> et n’a aucun résultat à fournir. La constante ne précise pas la raison de cette absence.

o == std::nullopt et !o.has_value() testent l’absence de valeur. if (o) teste la présence, pas le contenu : 0, false ou nullptr, s’ils sont stockés, sont des valeurs présentes. N’utilisez *o et o-> qu’en présence d’une valeur. En C++23, ces opérateurs ont un comportement indéfini sur un objet vide, tandis que o.value() lève std::bad_optional_access. o = std::nullopt et o.reset() détruisent l’éventuelle valeur stockée ; n’utilisez plus les pointeurs ou références qui la désignaient.

Dans la leçon 51, std::numeric_limits<int> de <limits> fournit les bornes de int : max() donne la plus grande valeur représentable et min() la plus petite. Pour les types flottants avec valeurs sous-normales, min() donne la plus petite valeur positive normalisée ; lowest() donne la plus petite valeur finie. L’exemple vérifie la borne correspondant au signe de b avant d’évaluer a + b. L’évaluation en court-circuit de && garantit que les soustractions restent elles-mêmes dans l’intervalle. Une somme de type int hors limites aurait un comportement indéfini.

Dans la leçon 48, std::filesystem::perms de <filesystem> est une énumération de type enum class servant de masque de bits pour les permissions de fichier. La présence de std::filesystem::perms::none indique qu’aucun bit de permission n’est activé ; un std::optional<std::filesystem::perms> vide indique l’absence de résultat. Il s’agit uniquement de contexte : l’exemple n’utilise pas ce type et ne vérifie ni ne fait respecter les permissions.

Exemples

#include <iostream>
#include <limits>
#include <optional>

std::optional<int> checked_add(int a, int b) {
    using Limits = std::numeric_limits<int>;
    if ((b > 0 && a > Limits::max() - b) ||
        (b < 0 && a < Limits::min() - b)) {
        return std::nullopt;
    }
    return a + b;
}

int main() {
    const auto print = [](std::optional<int> result) {
        if (result) {
            std::cout << *result << '\n';
        } else {
            std::cout << "no result\n";
        }
    };

    print(checked_add(7, -7));
    print(checked_add(std::numeric_limits<int>::max(), 1));
    print(checked_add(std::numeric_limits<int>::min(), -1));
}

Résultat

0
no result
no result

Le premier appel affiche `0` ; les deux suivants affichent chacun `no result`, car la somme est hors des limites de `int`.

Leçons associées

  • C++ · Leçon 48 · Avancé · Version : 3
  • C++ · Leçon 51 · Avancé · Version : 3

Sources