std::projected

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Iterator-Bibliothek

Iterator-Konzepte
indirectly_readable (C++20) indirectly_writable (C++20) weakly_incrementable (C++20) incrementable (C++20) is-integer-like is-signed-integer-like (C++20)(C++20)	sentinel_for (C++20) sized_sentinel_for (C++20) input_iterator (C++20) output_iterator (C++20) input_or_output_iterator (C++20)	forward_iterator (C++20) bidirectional_iterator (C++20) random_access_iterator (C++20) contiguous_iterator (C++20)
Iterator-Primitive
input_iterator_tagoutput_iterator_tagforward_iterator_tagbidirectional_iterator_tagrandom_access_iterator_tagcontiguous_iterator_tag (C++20)	iter_value_titer_difference_titer_reference_titer_const_reference_titer_rvalue_reference_titer_common_reference_t (C++20)(C++20)(C++20)(C++23)(C++20)(C++20)	iterator (veraltet in C++17) iterator_traits incrementable_traits (C++20) indirectly_readable_traits (C++20)
Algorithmus-Konzepte und Hilfsprogramme
Indirekte aufrufbare Konzepte
indirectly_unary_invocableindirectly_regular_unary_invocable (C++20)(C++20)	indirect_unary_predicate (C++20) indirect_binary_predicate (C++20)	indirect_equivalence_relation (C++20) indirect_strict_weak_order (C++20)
Gemeinsame Algorithmus-Anforderungen
indirectly_movable (C++20) indirectly_movable_storable (C++20) indirectly_copyable (C++20)	indirectly_copyable_storable (C++20)   indirectly_swappable (C++20) indirectly_comparable (C++20)	permutable (C++20) mergeable (C++20) sortable (C++20)
Dienstprogramme
indirect_result_t (C++20)	projected (C++20)	projected_value_t (C++26)
Iterator-Adapter
reverse_iterator make_reverse_iterator (C++14) move_iterator (C++11) make_move_iterator (C++11) default_sentinel_tdefault_sentinel (C++20)(C++20) unreachable_sentinel_tunreachable_sentinel (C++20)(C++20)	front_insert_iterator back_insert_iterator inserter insert_iterator front_inserter back_inserter move_sentinel (C++20)	common_iterator (C++20) counted_iterator (C++20) basic_const_iterator (C++23) const_iterator (C++23) const_sentinel (C++23) make_const_iterator (C++23) make_const_sentinel (C++23)
Stream-Iteratoren istream_iterator    ostream_iterator istreambuf_iterator ostreambuf_iterator	Iterator-Anpassungspunkte ranges::iter_move (C++20) ranges::iter_swap (C++20)
Iterator-Operationen advance distance prev (C++11)   next (C++11) ranges::advance (C++20) ranges::distance (C++20) ranges::prev (C++20) ranges::next (C++20)	Bereichszugriff begincbegin (C++11)(C++14) rbegincrbegin (C++14)(C++14)   endcend (C++11)(C++14) rendcrend (C++14)(C++14)   sizessize (C++17)(C++20) empty (C++17) data (C++17)

 

Definiert in 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*/; // siehe (3)			(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)
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 Exposition*)

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 die 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 Schicht, die verwendet wird, um unerwartete argumentabhängige Suche zu vermeiden. Der Mitgliedstyp difference_type existiert nur, wenn I weakly_incrementable modelliert.

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

Template-Parameter

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

Hinweise

Die indirekte Schicht 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 Schicht den unnötigen Versuch, die Definition dieses Typs zu untersuchen, was zu einem harten Fehler führt.

Beispiel

Führen Sie diesen Code aus

#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 before C++26
static_assert(std::sortable<P*>); // Error before C++26
 
int main()
{
    P a[10] = {}; // ten null pointers
    assert(std::count(a, a + 10, nullptr) == 10); // OK
    assert(std::ranges::count(a, a + 10, nullptr) == 10); // Error before C++26
}

Siehe auch

projected_value_t (C++26)

berechnet den Werttyp eines indirectly_readable Typs mittels Projektion (Alias-Vorlage)