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

CKTIS / C++

std::optional — une valeur qui peut être absente

std::optional<T> représente soit un objet de type T, soit l’absence de valeur. Il permet de distinguer un résultat manquant de valeurs valides comme 0. Vérifiez qu’une valeur est présente avant d’utiliser les opérateurs * et ->.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

#include <optional>
std::optional<T> item;
std::optional<T> empty = std::nullopt;
if (item) { /* *item; item->member; */ }

std::optional<T>, déclaré dans <optional>, stocke une valeur de type T dans son propre objet ou ne contient aucune valeur. Il est utile lorsqu’une fonction peut ne pas produire de résultat, mais que vous n’avez pas besoin d’une description de l’erreur. La construction par défaut avec std::optional<T> item; crée un état vide ; la construction à partir d’une valeur de type T crée un état contenant une valeur.

std::nullopt est la constante qui indique l’absence de valeur, et std::nullopt_t est son type marqueur distinct, et non le type du résultat stocké. Utilisez return std::nullopt; pour renvoyer un résultat vide, ou item = std::nullopt; pour supprimer la valeur stockée.

std::optional::operator bool est une conversion explicite qui vérifie la présence d’une valeur ; elle fonctionne dans if (item), comme item.has_value(). Elle ne teste pas la valeur stockée elle-même : un objet contenant 0 ou false renvoie tout de même true.

std::optional::operator* donne accès à la valeur stockée par référence, tandis que std::optional::operator-> permet d’accéder à ses membres. Les deux exigent qu’une valeur soit présente. En C++23, utiliser l’un ou l’autre sur un objet vide entraîne un comportement indéfini ; ne vous attendez pas à une exception. La méthode value() vérifie cet état et lance std::bad_optional_access lorsqu’aucune valeur n’est présente.

Cette entrée concerne C++23 : l’option du compilateur utilisée dans le dépôt, sans attestation de l’environnement d’exécution en production. Le projet de norme lié est mis à jour et comprend également des extensions ultérieures ; son contenu entier ne doit pas être considéré comme du C++23.

Exemples

#include <iostream>
#include <optional>

struct Item {
    int count;
};

std::optional<Item> find_item(bool available) {
    if (available) {
        return Item{0};
    }
    return std::nullopt;
}

int main() {
    const auto item = find_item(true);
    if (item) {
        std::cout << item->count << ' ' << (*item).count << '\n';
    }

    const auto missing = find_item(false);
    std::cout << std::boolalpha << missing.has_value() << '\n';
}

Résultat

0 0
false

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources