C++ named requirements: NullablePointer (since C++11)

Spécifie que le type est un objet de type pointeur qui peut être comparé à std::nullptr_t objects.

Exigences

Le type doit satisfaire à toutes les exigences suivantes :

• EqualityComparable
• DefaultConstructible
• CopyConstructible
• CopyAssignable
• Swappable
• Destructible

De plus, un objet initialisé par valeur de ce type doit produire une valeur nulle de ce type. Cette valeur nulle ne doit être équivalente qu'à elle-même. L'initialisation par défaut du type peut avoir une valeur indéterminée ou erronée (depuis C++26) .

Une valeur du type doit être contextuellement convertible en bool . L'effet de cette conversion retourne false si la valeur est équivalente à sa valeur nulle et true dans le cas contraire.

Aucune des opérations que ce type effectue ne peut lever d'exceptions.

Le type doit satisfaire les expressions supplémentaires suivantes, étant donné deux valeurs p et q de ce type, et que np est une valeur de type std::nullptr_t (éventuellement qualifié const) :

Notes

Notez que le déréférencement ( operator * ou operator - > ) n'est pas requis pour un type NullablePointer . Un type minimaliste qui satisfait ces exigences est

class handle
{
    int id = 0;
public:
    handle() = default;
    handle(std::nullptr_t) {}
    explicit operator bool() const { return id != 0; }
    friend bool operator==(handle l, handle r) { return l.id == r.id; }
    friend bool operator!=(handle l, handle r) { return !(l == r); }
    // ou seulement un operator== par défaut (depuis C++20)
};

Bibliothèque standard

Les types suivants satisfont NullablePointer :

• std::exception_ptr .

Les types suivants doivent satisfaire NullablePointer afin de pouvoir communiquer avec les composants de la bibliothèque standard :

• Les types membres X::pointer , X::const_pointer , X::void_pointer et X::const_void_pointer de chaque type Allocator X .
• Le type membre pointer de std::unique_ptr .

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.