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)
Definiert im Header <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 ; // nicht definiert

} ;
(seit C++20)
(bis C++26)
template < std:: indirectly_readable I,

std:: indirectly_regular_unary_invocable < I > Proj >

using projected = /*projected-impl*/ < I, Proj > :: /*type*/ ;
(seit 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) (seit C++20)
(bis C++26)
Hilfsvorlagen
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 > ; // bedingt vorhanden
std:: indirect_result_t < Proj & , I > operator * ( ) const ; // nicht definiert
} ;

} ;
(3) (seit C++26)
( nur zur Darstellung* )
1) Klasse (bis C++26) Alias (seit C++26) Template projected kombiniert einen indirectly_readable -Typ I und einen aufrufbaren Objekttyp Proj zu einem neuen indirectly_readable -Typ, dessen Referenztyp das Ergebnis der Anwendung von Proj auf den std:: iter_reference_t < I > ist.
2) Diese Spezialisierung von std::incrementable_traits macht std :: projected < I, Proj > zu einem weakly_incrementable -Typ, wenn I ebenfalls ein weakly_incrementable -Typ ist.
3) Eine indirekte Ebene, die verwendet wird, um unerwartete argument-dependent lookup zu vermeiden.
Für die nur zur Darstellung dienende geschachtelte Klasse /*type*/ existiert der geschachtelte Typ difference_type nur, wenn I das Konzept weakly_incrementable modelliert.

projected wird nur verwendet, um Algorithmen einzuschränken, die aufrufbare Objekte und Projektionen akzeptieren, und daher ist sein operator * ( ) nicht definiert.

Inhaltsverzeichnis

Template-Parameter

I - ein indirekt lesbarer Typ
Proj - Projektion angewendet auf ein dereferenziertes I

Hinweise

Die indirekte Ebene verhindert, dass I und Proj assoziierte Klassen von projected sind. Wenn eine assoziierte Klasse von I oder Proj ein unvollständiger Klassentyp ist, vermeidet die indirekte Ebene den unnötigen Versuch, die Definition dieses Typs zu inspizieren, was zu einem schwerwiegenden Fehler führen würde.

Beispiel

Diesen Code ausführen 
#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<>>); // Fehler vor C++26
static_assert(std::sortable<P*>); // Fehler vor C++26
int main()
{
    P a[10] = {}; // zehn Nullzeiger
    assert(std::count(a, a + 10, nullptr) == 10); // OK
    assert(std::ranges::count(a, a + 10, nullptr) == 10); // Fehler vor C++26
}

Siehe auch

(C++26)
berechnet den Werttyp eines indirectly_readable Typs durch Projektion
(Alias-Template)