std::ranges::subrange<I,S,K>::operator PairLike

template< /* see below */ PairLike > requires pair-like-convertible-from<PairLike, const I&, const S&> constexpr operator PairLike() const;	(1)	(с C++20)
Вспомогательные концепции
template< class T > concept pair-like = !std::is_reference_v<T> && requires(T t) { typename std::tuple_size<T>::type; // ensures std::tuple_size<T> // is complete requires std::derived_from<std::tuple_size<T>, std::integral_constant<std::size_t, 2>>; typename std::tuple_element_t<0, std::remove_const_t<T>>; typename std::tuple_element_t<1, std::remove_const_t<T>>; { std::get<0>(t) } -> std::convertible_to< const std::tuple_element_t<0, T>&>; { std::get<1>(t) } -> std::convertible_to< const std::tuple_element_t<1, T>&>; };	(2)	(до C++23) (только для примера*)
	(3)
template< class T, class U, class V > concept pair-like-convertible-from = !ranges::range<T> && pair-like<T> && std::constructible_from<T, U, V> && convertible-to-non-slicing<U, std::tuple_element_t<0, T>> && std::convertible_to<V, std::tuple_element_t<1, T>>;		(до C++23) (только для примера*)
template< class T, class U, class V > concept pair-like-convertible-from = !ranges::range<T> && !std::is_reference_v<T> && pair-like<T> && std::constructible_from<T, U, V> && convertible-to-non-slicing<U, std::tuple_element_t<0, T>> && std::convertible_to<V, std::tuple_element_t<1, T>>;		(с C++23) (только для примера*)

1) Преобразует subrange в тип, подобный паре (т.е. тип моделирует вспомогательную концепцию pair-like , определённую ниже(до C++23)pair-like(с C++23)). Эквивалентно return PairLike(i_, s_);, где i_ и s_ соответственно хранимый итератор и конечная точка.

PairLike ограничено тем, что std::same_as<std::remove_cvref_t<PairLike>, subrange> является false.

Эта функция преобразования имеет дополнительные ограничения, налагаемые pair-like-convertible (см. ниже).

2) Концепция pair-like (только для примера) определяет, что тип похож на пару. В общем случае выражение e типа, подобного паре, может использоваться для структурированных связываний (т.е. auto const& [x, y] = e; обычно является корректным). Эта концепция заменена библиотечной концепцией pair-like (только для примера).(с C++23)

3) Концепция pair-like-convertible-from (только для примера) уточняет pair-like. Она

отвергает типы ссылок и (с C++23)range типы,
требует, чтобы U и V были преобразуемы к первому и второму типу элемента T соответственно, и
требует, чтобы преобразование U (которое будет заменено на const I&) в первый тип элемента не было "срезающим" (см. convertible-to-non-slicing).

Параметры

(нет)

Значение возврата

Значение типа PairLike, инициализированное сохранённым итератором и конечной точкой.

Примечания

Следующие типы стандартной библиотеки являются типами, подобными парам:

std::pair<T, U>
std::tuple<T, U>
std::array<T, 2>
std::ranges::subrange<I, S, K>

Тип, определённый программистом и производный от одного из этих типов, может быть типом, подобным паре, если

std::tuple_size и std::tuple_element корректно специализированы для него, и
вызовы std::get<0> и std::get<1> для его значения являются корректными.

(до C++23)

Так как subrange специализации являются range типами, преобразования к ним не выполняются через эту функцию преобразования.

std::array специализации не могут быть преобразованы из subrange, так как они являются range типами.

Пример

#include <iostream>
#include <ranges>
#include <string>
#include <utility>
 
using striter = std::string::const_iterator;
 
using legacy_strview = std::pair<striter, striter>;
 
void legacy_print(legacy_strview p)
{
    for (; p.first != p.second; ++p.first)
        std::cout << *p.first << ' ';
    std::cout << '\n';
}
 
int main()
{
    std::string dat{"ABCDE"};
    for (auto v{std::ranges::subrange{dat}}; v; v = {v.begin(), v.end() - 1})
    {
        /*...*/
        legacy_print(legacy_strview{v});
    }
}

Вывод:

A B C D E 
A B C D 
A B C 
A B 
A

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/ranges/subrange/operator_PairLike