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

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Technical specifications

Symbols index

External libraries

 

C++ named requirements

Basic
DefaultConstructible CopyAssignable	CopyConstructible MoveAssignable (C++11)	MoveConstructible (C++11) Destructible
Type properties
ScalarType TriviallyCopyable (C++11)	StandardLayoutType (C++11) PODType	TrivialType (C++11) ImplicitLifetimeType
Library-Wide
EqualityComparable LessThanComparable Swappable ValueSwappable (C++11)	NullablePointer (C++11) Hash (C++11) Allocator FunctionObject	Callable Predicate BinaryPredicate Compare
Container
Container SequenceContainer ContiguousContainer (C++17)	ReversibleContainer AssociativeContainer AllocatorAwareContainer	UnorderedAssociativeContainer (C++11)
Container Elements
DefaultInsertable (C++11) CopyInsertable (C++11)	MoveInsertable (C++11) EmplaceConstructible (C++11)	Erasable (C++11)
Iterator
LegacyIterator LegacyOutputIterator LegacyInputIterator	LegacyForwardIterator LegacyBidirectionalIterator LegacyRandomAccessIterator	LegacyContiguousIterator (C++17) ConstexprIterator (C++20)
Stream I/O
FormattedInputFunction UnformattedInputFunction	FormattedOutputFunction	UnformattedOutputFunction
Formatters
BasicFormatter (C++20)	Formatter (C++20)
Random Numbers
SeedSequence (C++11) RandomNumberEngine (C++11)	RandomNumberDistribution (C++11) UniformRandomBitGenerator (C++11)	RandomNumberEngineAdaptor (C++11)
Concurrency
BasicLockable (C++11) Lockable (C++11) TimedLockable (C++11)	SharedLockable (C++14) SharedTimedLockable (C++14) Mutex (C++11)	TimedMutex (C++11) SharedMutex (C++17) SharedTimedMutex (C++14)
Ranges
RangeAdaptorObject (C++20)	RangeAdaptorClosureObject (C++20)
Other
CharTraits RegexTraits (C++11) BitmaskType LiteralType (C++11)	NumericType UnaryTypeTrait (C++11) BinaryTypeTrait (C++11) TransformationTrait (C++11)	Clock (C++11) TrivialClock (C++11)

 

Specifies that the type is a pointer-like object which can be compared to std::nullptr_t objects.

Requirements

The type must meet all of the following requirements:

• EqualityComparable
• DefaultConstructible
• CopyConstructible
• CopyAssignable

lvalues of the type are Swappable	(until C++23)
Swappable	(since C++23)

• Destructible

In addition, a value-initialized object of the type must produce a null value of that type. This null value shall only be equivalent to itself. Default initialization of the type may have an indeterminate value.

An object of the type must be contextually convertible to bool. The effect of this conversion returns false if the value is equivalent to its null value and true otherwise.

None of the operations that this type performs may throw exceptions.

The type must satisfy the following additional expressions, given two values p and q that are of the type, and that np is a value of std::nullptr_t type (possibly const qualified):

Expression	Effects
Type p(np); Type p = np;	Afterwards, p is equivalent to nullptr
Type(np)	A temporary object that is equivalent to nullptr
p = np	Must return a Type&, and afterwards, p is equivalent to nullptr
p != q	Must return a value that is contextually convertible to bool (until C++23) decltype(p != q) models boolean-testable (since C++23) The effect is !(p == q)
p == np np == p	Must return a value that is contextually convertible to bool (until C++23) decltype(p == np) and decltype(np == p) each model boolean-testable (since C++23) The effect is (p == Type())
p != np np != p	Must return a value that is contextually convertible to bool (until C++23) decltype(p != np) and decltype(np != p) each model boolean-testable (since C++23) The effect is !(p == np)

Notes

Note that dereferencing (operator* or operator->) is not required of a NullablePointer type. A minimalistic type that satisfies these requirements is

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); }
    // or only a defaulted operator== (since C++20)
};

Standard library

The following types must satisfy NullablePointer:

• The member types X::pointer, X::const_pointer, X::void_pointer and X::const_void_pointer of every Allocator type X.
• The member type X::pointer of std::unique_ptr.
• The type std::exception_ptr.