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_tsentinel_t	range_difference_trange_value_t	range_reference_trange_rvalue_reference_t
Dangling iterator handling
dangling	borrowed_iterator_t	borrowed_subrange_t
Range concepts
range borrowed_range sized_range	common_range view viewable_range	input_range output_range forward_range	bidirectional_range random_access_range contiguous_range
Views
view_interface	subrange
Semiregular wrapper
Factories
empty_viewviews::empty	single_viewviews::single	iota_viewviews::iota	views::counted
Adaptors
all_viewviews::all join_viewviews::join take_viewviews::take basic_istream_viewistream_view	ref_view                                split_viewviews::split take_while_viewviews::take_while elements_viewviews::elements	common_viewviews::common transform_viewviews::transform drop_viewviews::drop keys_viewviews::keys	reverse_viewviews::reverse filter_viewviews::filter drop_while_viewviews::drop_while values_viewviews::values

 

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

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

semiregular_box<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 copy_constructible

Member functions

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

semiregular_box::semiregular_box

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

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

constexpr semiregular_box() noexcept(std::is_nothrow_default_constructible_v<T>)
  : semiregular_box{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_box::operator=

semiregular_box& operator=(const semiregular_box& other)     noexcept(std::is_nothrow_copy_constructible_v<T>)	(1)
semiregular_box& operator=(semiregular_box&& 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>)