Semiregular wrapper (C++20)

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Ranges library

Range access
begincbegin endcend	rbegincrbegin rendcrend	size empty datacdata
Range primitives
iterator_t	sentinel_t
Dangling iterator handling
dangling	safe_iterator_t	safe_subrange_t
Range concepts
Range SizedRange View	InputRange OutputRange ForwardRange	BidirectionalRange RandomAccessRange ContiguousRange	CommonRange ViewableRange
Views
view_interface	subrange
Semiregular wrapper
Factories
empty_viewview::empty	single_viewview::single	iota_viewview::iota	view::counted
Adaptors
all_viewview::all ref_view filter_viewview::filter	transform_viewview::transform                                take_viewview::take	join_viewview::join split_viewview::split	common_viewview::common reverse_viewview::reverse

 

template<class T>     requires std::CopyConstructible<T> && std::is_object_v<T> class /*semiregular*/;		(since C++20)

ranges::single_view, ranges::filter_view and ranges::transform_view are specified in terms of an exposition-only class template semiregular. The name semiregular is for exposition purposes only and not normative.

semiregular<T> behaves exactly like std::optional<T> with a little differences, which makes it model Semiregular.

Template parameters

T

-

the type of the value to manage initialization state for. The type must be a object type and model CopyConstructible

Member functions

Following member functions are conditionally different from corresponding member functions of std::optional.

semiregular::semiregular

constexpr semiregular() noexcept(std::is_nothrow_default_constructible_v<T>);

If T models DefaultConstructible, the default constructor of semiregular<T> constructs a semiregular wrapper containing a value-initialized T and is equivalent to:

constexpr semiregular() noexcept(std::is_nothrow_default_constructible_v<T>)
  : semiregular{std::in_place}
{ }

Otherwise, the default constructor is equivalent to the default constructor of std::optional and constructs a semiregular wrapper which does not contain a value.

semiregular::operator=

semiregular& operator=(const semiregular& other)     noexcept(std::is_nothrow_copy_constructible_v<T>)	(1)
semiregular& operator=(semiregular&& other)     noexcept(std::is_nothrow_move_constructible_v<T>)	(2)

1) If Assignable<T&, const T&> is not satisfied, the copy assignment operator's body is equivalent to if (other) emplace(*other); else reset(); return *this;.
Otherwise, the copy assignment operator is identical to the copy assignment operator of std::optional.

2) If Assignable<T&, T> is not satisfied, the move assignment operator's body is equivalent to if (other) emplace(std::move(*other)); else reset(); return *this;.
Otherwise, the move assignment operator is identical to the move assignment operator of std::optional.

Members identical to std::optional

Member functions

(constructor)	constructs the optional object (public member function of std::optional<T>)
(destructor)	destroys the contained value, if there is one (public member function of std::optional<T>)
operator=	assigns contents (public member function of std::optional<T>)
Observers
operator->operator*	accesses the contained value (public member function of std::optional<T>)
operator boolhas_value	checks whether the object contains a value (public member function of std::optional<T>)
Modifiers
reset	destroys any contained value (public member function of std::optional<T>)
emplace	constructs the contained value in-place (public member function of std::optional<T>)