NAME¶

std::ranges::views::single,std::ranges::single_view - std::ranges::views::single,std::ranges::single_view

Synopsis¶

Defined in header <ranges>
template< std::copy_constructible T >

requires std::is_object_v<T> (since C++20)
class single_view (until C++23)

: public ranges::view_interface<single_view<T>>
template< std::move_constructible T >

requires std::is_object_v<T> (since C++23)
class single_view

: public ranges::view_interface<single_view<T>> (1)
namespace views {

inline constexpr /*unspecified*/ single = /*unspecified*/; (2) (since C++20)

}
Call signature
template< class T >

requires /* see below */ (since C++20)

constexpr /*see below*/ single( T&& t );

1) Produces a view that contains exactly one element of a specified value.
2) The expression views::single(e) is expression-equivalent to
single_view<std::decay_t<decltype((e))>>(e) for any suitable subexpression e.

The lifetime of the element is bound to the parent single_view. Copying single_view
makes a copy of the element.

Member functions¶

constructor constructs a single_view
(C++20) (public member function)
begin returns a pointer to the element
(C++20) (public member function)
end returns a pointer past the element
(C++20) (public member function)
size returns 1 (one)
[static] (C++20) (public static member function)
data returns a pointer to the element
(C++20) (public member function)
Inherited from std::ranges::view_interface
empty returns whether the derived view is empty. Provided if it satisfies
(C++20) sized_range or forward_range.
(public member function of std::ranges::view_interface<D>)
cbegin returns a constant iterator to the beginning of the range.
(C++23) (public member function of std::ranges::view_interface<D>)
cend returns a sentinel for the constant iterator of the range.
(C++23) (public member function of std::ranges::view_interface<D>)
operator bool returns whether the derived view is not empty. Provided if
(C++20) ranges::empty is applicable to it.
(public member function of std::ranges::view_interface<D>)
front returns the first element in the derived view. Provided if it
(C++20) satisfies forward_range.
(public member function of std::ranges::view_interface<D>)
back returns the last element in the derived view. Provided if it
(C++20) satisfies bidirectional_range and common_range.
(public member function of std::ranges::view_interface<D>)
operator[] returns the n^th element in the derived view. Provided if it
(C++20) satisfies random_access_range.
(public member function of std::ranges::view_interface<D>)

std::ranges::single_view::single_view

single_view() requires std::default_initializable<T> (1) (since C++20)
= default;
constexpr explicit single_view( const T& t ); (since C++20)
(until C++23)
constexpr explicit single_view( const T& t ) (since C++23)
requires std::copy_constructible<T>;
constexpr explicit single_view( T&& t ); (3) (since C++20)
template< class... Args > (2)

requires std::constructible_from<T, Args...> (4) (since C++20)

constexpr explicit single_view( std::in_place_t,
Args&&... args );

Constructs a single_view.

1) Default initializes value_, which value-initializes its contained value.
2) Initializes value_ with t.
3) Initializes value_ with std::move(t).
4) Initializes value_ as if by value_{std::in_place, std::forward<Args>(args)...}.

std::ranges::single_view::begin

constexpr T* begin() noexcept; (since C++20)
constexpr const T* begin() const noexcept;

Equivalent to return data();.

std::ranges::single_view::end

constexpr T* end() noexcept; (since C++20)
constexpr const T* end() const noexcept;

Equivalent to return data() + 1;.

std::ranges::single_view::size

static constexpr std::size_t size() noexcept; (since C++20)

Equivalent to return 1;.

This is a static function. This makes single_view model /*tiny-range*/ as required
by split_view.

std::ranges::single_view::data

constexpr T* data() noexcept; (since C++20)
constexpr const T* data() const noexcept;

Returns a pointer to the contained value of value_. The behavior is undefined if
value_ does not contains a value.

Deduction guides

template< class T > (since C++20)
single_view( T ) -> single_view<T>;

Notes¶

For a single_view, the inherited empty member function always returns false, and the
inherited operator bool conversion function always returns true.

Example¶

// Run this code

#include <iomanip>
#include <iostream>
#include <ranges>
#include <string>
#include <tuple>

int main()
{
constexpr std::ranges::single_view sv1{3.1415}; // uses (const T&) constructor
static_assert(sv1);
static_assert(not sv1.empty());

std::cout << "1) *sv1.data(): " << *sv1.data() << '\n'
<< "2) *sv1.begin(): " << *sv1.begin() << '\n'
<< "3) sv1.size(): " << sv1.size() << '\n'
<< "4) distance: " << std::distance(sv1.begin(), sv1.end()) << '\n';

std::string str{"C++20"};
std::cout << "5) str = " << std::quoted(str) << '\n';
std::ranges::single_view sv2{std::move(str)}; // uses (T&&) constructor
std::cout << "6) *sv2.data(): " << std::quoted(*sv2.data()) << '\n'
<< "7) str = " << std::quoted(str) << '\n';

std::ranges::single_view<std::tuple<int, double, std::string>>
sv3{std::in_place, 42, 3.14, "😄"}; // uses (std::in_place_t, Args&&... args)

std::cout << "8) sv3 holds a tuple: { "
<< std::get<0>(sv3[0]) << ", "
<< std::get<1>(sv3[0]) << ", "
<< std::get<2>(sv3[0]) << " }\n";
}

Output:¶

1) *sv1.data(): 3.1415
2) *sv1.begin(): 3.1415
3) sv1.size(): 1
4) distance: 1
5) str = "C++20"
6) *sv2.data(): "C++20"
7) str = ""
8) sv3 holds a tuple: { 42, 3.14, 😄 }

Defect reports

The following behavior-changing defect reports were applied retroactively to
previously published C++ standards.

DR Applied to Behavior as published Correct behavior
LWG 3428 C++20 single_view was convertible from the constructor is made
std::in_place_t explicit
deduction guides for single_view
P2367R0 C++20 failed to decay the argument; a decaying guide provided;
views::single copied but not wrapped made always wrapping
a single_view

See also¶

ranges::empty_view an empty view with no elements
views::empty (class template) (variable template)
(C++20)
ranges::split_view a view over the subranges obtained from splitting another view
views::split using a delimiter
(C++20) (class template) (range adaptor object)