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)
Défini dans l'en-tête <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 ; // non défini

} ;
(depuis C++20)
(jusqu'à C++26)
template < std:: indirectly_readable I,

std:: indirectly_regular_unary_invocable < I > Proj >

using projected = /*projected-impl*/ < I, Proj > :: /*type*/ ;
(depuis 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) (depuis C++20)
(jusqu'à C++26)
Modèles auxiliaires
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 > ; // conditionnellement présent
std:: indirect_result_t < Proj & , I > operator * ( ) const ; // non défini
} ;

} ;
(3) (depuis C++26)
( exposition uniquement* )
1) Classe (jusqu'au C++26) Alias (depuis C++26) template projected combine un type indirectly_readable I et un type d'objet appelable Proj en un nouveau type indirectly_readable dont le type de référence est le résultat de l'application de Proj au std:: iter_reference_t < I > .
2) Cette spécialisation de std::incrementable_traits fait de std :: projected < I, Proj > un type weakly_incrementable lorsque I est également un type weakly_incrementable .
3) Une couche indirecte utilisée pour éviter une argument-dependent lookup inattendue.
Pour la classe imbriquée à titre d'exposition uniquement /*type*/ , le type imbriqué difference_type existe uniquement si I modélise weakly_incrementable .

projected est utilisé uniquement pour contraindre les algorithmes qui acceptent des objets appelables et des projections, et donc son operator * ( ) n'est pas défini.

Table des matières

Paramètres du modèle

I - un type indirectement lisible
Proj - projection appliquée à un déréférencé I

Notes

La couche indirecte empêche I et Proj d'être des classes associées de projected . Lorsqu'une classe associée de I ou Proj est un type de classe incomplet, la couche indirecte évite la tentative inutile d'inspecter la définition de ce type qui entraînerait une erreur irrécupérable.

Exemple

Exécuter ce code 
#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<>>); // Erreur avant C++26
static_assert(std::sortable<P*>); // Erreur avant C++26
int main()
{
    P a[10] = {}; // dix pointeurs nuls
    assert(std::count(a, a + 10, nullptr) == 10); // OK
    assert(std::ranges::count(a, a + 10, nullptr) == 10); // Erreur avant C++26
}

Voir aussi

(C++26)
calcule le type de valeur d'un indirectly_readable par projection
(alias de modèle)