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)
Definido en el encabezado <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 ; // no definido

} ;
(desde C++20)
(hasta C++26)
template < std:: indirectly_readable I,

std:: indirectly_regular_unary_invocable < I > Proj >

using projected = /*projected-impl*/ < I, Proj > :: /*type*/ ;
(desde 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) (desde C++20)
(hasta C++26)
Plantillas auxiliares
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 > ; // condicionalmente presente
std:: indirect_result_t < Proj & , I > operator * ( ) const ; // no definido
} ;

} ;
(3) (desde C++26)
( solo para exposición* )
1) Clase (hasta C++26) Alias (desde C++26) template projected combina un tipo indirectly_readable I y un tipo de objeto invocable Proj en un nuevo tipo indirectly_readable cuyo tipo de referencia es el resultado de aplicar Proj al std:: iter_reference_t < I > .
2) Esta especialización de std::incrementable_traits hace que std :: projected < I, Proj > sea un tipo weakly_incrementable cuando I también es un tipo weakly_incrementable .
3) Una capa indirecta utilizada para evitar la búsqueda dependiente de argumentos inesperada.
Para la clase anidada solo de exposición /*type*/ , el tipo anidado difference_type existe solo si I modela weakly_incrementable .

projected se utiliza únicamente para restringir algoritmos que aceptan objetos invocables y proyecciones, y por lo tanto su operator * ( ) no está definido.

Contenidos

Parámetros de plantilla

I - un tipo indirectamente legible
Proj - proyección aplicada a un valor desreferenciado I

Notas

La capa indirecta evita que I y Proj sean clases asociadas de projected . Cuando una clase asociada de I o Proj es un tipo de clase incompleta, la capa indirecta evita el intento innecesario de inspeccionar la definición de ese tipo que resultaría en un error grave.

Ejemplo

Ejecutar este código 
#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<>>); // Error antes de C++26
static_assert(std::sortable<P*>); // Error antes de C++26
int main()
{
    P a[10] = {}; // diez punteros nulos
    assert(std::count(a, a + 10, nullptr) == 10); // OK
    assert(std::ranges::count(a, a + 10, nullptr) == 10); // Error antes de C++26
}

Véase también

(C++26)
calcula el tipo de valor de un indirectly_readable mediante proyección
(alias de plantilla)