Namespaces
Variants

std:: projected

From cppreference.net
C++
Iterator library
Iterator concepts
Iterator primitives
Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
projected
(C++20)
Iterator adaptors
Range access
(C++11) (C++14)
(C++14) (C++14)
(C++11) (C++14)
(C++14) (C++14)
(C++17) (C++20)
(C++17)
(C++17)
Определено в заголовке <iterator>
(1)
template < std:: indirectly_readable I,

std:: indirectly_regular_unary_invocable < I > Proj >
struct projected
{
using value_type = std:: remove_cvref_t
< std:: indirect_result_t < Proj & , I >> ;
std:: indirect_result_t < Proj & , I > operator * ( ) const ; // не определен

} ;
(начиная с C++20)
(до C++26)
template < std:: indirectly_readable I,

std:: indirectly_regular_unary_invocable < I > Proj >

using projected = /*projected-impl*/ < I, Proj > :: /*type*/ ;
(начиная с C++26)
template < std:: weakly_incrementable I, class Proj >

struct incrementable_traits < std :: projected < I, Proj >>
{
using difference_type = std:: iter_difference_t < I > ;

} ;
(2) (начиная с C++20)
(до C++26)
Вспомогательные шаблоны
template < class I, class Proj >

struct /*projected-impl*/
{
struct /*type*/
{
using value_type = std:: remove_cvref_t
< std:: indirect_result_t < Proj & , I >> ;
using difference_type =
std:: iter_difference_t < I > ; // условно присутствует
std:: indirect_result_t < Proj & , I > operator * ( ) const ; // не определен
} ;

} ;
(3) (начиная с C++26)
( только для демонстрации* )
1) Класс (до C++26) Псевдоним (начиная с C++26) шаблон projected комбинирует indirectly_readable тип I и тип вызываемого объекта Proj в новый тип indirectly_readable , ссылочный тип которого является результатом применения Proj к std:: iter_reference_t < I > .
2) Эта специализация std::incrementable_traits делает std :: projected < I, Proj > типом weakly_incrementable когда I также является типом weakly_incrementable .
3) Косвенный слой, используемый для предотвращения непредвиденного argument-dependent lookup .
Для демонстрационного вложенного класса /*type*/ , вложенный тип difference_type существует только если I моделирует weakly_incrementable .

projected используется только для ограничения алгоритмов, принимающих вызываемые объекты и проекции, поэтому его operator * ( ) не определён.

Содержание

Параметры шаблона

I - косвенно читаемый тип
Proj - проекция, применяемая к разыменованному I

Примечания

Косвенный слой предотвращает I и Proj от того, чтобы быть ассоциированными классами projected . Когда ассоциированный класс I или Proj является неполным типом класса, косвенный слой избегает ненужной попытки инспекции определения этого типа, что приводит к жесткой ошибке.

Пример

Запустить этот код 
#include <algorithm>
#include <cassert>
#include <functional>
#include <iterator>
template<class T>
struct Holder
{
    T t;
};
struct Incomplete;
using P = Holder<Incomplete>*;
static_assert(std::equality_comparable<P>); // OK
static_assert(std::indirectly_comparable<P*, P*, std::equal_to<>>); // Ошибка до C++26
static_assert(std::sortable<P*>); // Ошибка до C++26
int main()
{
    P a[10] = {}; // десять нулевых указателей
    assert(std::count(a, a + 10, nullptr) == 10); // OK
    assert(std::ranges::count(a, a + 10, nullptr) == 10); // Ошибка до C++26
}

Смотрите также

(C++26)
вычисляет тип значения indirectly_readable типа через проекцию
(псевдоним шаблона)