Namespaces
Variants

    std::experimental::ranges:: count, std::experimental::ranges:: count_if

    From de.cppreference.net
    C++
    Experimental
    Ranges
    Algorithms library
    Non-modifying sequence operations
    Modifying sequence operations
    Partitioning operations
    Sorting operations
    Binary search operations
    Set operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    Permutations
    (Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur bleibt unverändert, wie angefordert.)
    template < InputIterator I, Sentinel < I > S, class T, class Proj = ranges:: identity >

    erfordert IndirectRelation < ranges:: equal_to <> , projected < I, Proj > , const T * >

    ranges :: difference_type_t < I > count ( I first, S last, const T & value, Proj proj = Proj { } ) ;
    		(1) (ranges TS)
    template < InputRange R, class T, class Proj = ranges:: identity >

    erfordert IndirectRelation < ranges:: equal_to <> ,
    projected < ranges:: iterator_t < R > , Proj > , const T * >
    ranges :: difference_type_t < ranges:: iterator_t < R >>

    count ( R && r, const T & value, Proj proj = Proj { } ) ;
    		(2) (ranges TS)
    template < InputIterator I, Sentinel < I > S, class Proj = ranges:: identity ,

    IndirectUnaryPredicate < projected < I, Proj >> Pred >

    ranges :: difference_type_t < I > count_if ( I first, S last, Pred pred, Proj proj = Proj { } ) ;
    		(3) (ranges TS)
    template < InputRange R, class Proj = ranges:: identity ,

    IndirectUnaryPredicate < projected < ranges:: iterator_t < R > , Proj >> Pred >
    ranges :: difference_type_t < ranges:: iterator_t < R >>

    count_if ( R && r, Pred pred, Proj proj = Proj { } ) ;
    		(4) (ranges TS)

    Gibt die Anzahl der Elemente im Bereich [ first , last ) zurück, die bestimmte Kriterien erfüllen.

    1) Zählt die Elemente, deren projizierte Werte gleich value sind (d.h., ranges:: invoke ( proj, * i ) == value ).
    3) Zählt die Elemente, deren projizierte Werte das Prädikat pred erfüllen (d.h., ranges:: invoke ( pred, ranges:: invoke ( proj, * i ) ) ! = false ).
    2,4) Gleich wie (1,3) , verwendet jedoch r als Quellbereich, als ob ranges:: begin ( r ) als first und ranges:: end ( r ) als last verwendet würde.

    Ungeachtet der oben dargestellten Deklarationen sind die tatsächliche Anzahl und Reihenfolge der Template-Parameter für Algorithmus-Deklarationen nicht spezifiziert. Daher ist ein Programm wahrscheinlich nicht portabel, wenn explizite Template-Argumente beim Aufruf eines Algorithmus verwendet werden.

    Inhalt

    Parameter

    first, last - der Bereich der zu untersuchenden Elemente
    r - der Bereich der zu untersuchenden Elemente
    value - der zu suchende Wert
    pred - Prädikat, das auf die projizierten Elemente angewendet wird
    proj - Projektion, die auf die Elemente angewendet wird

    Rückgabewert

    Anzahl der Elemente, die die Bedingung erfüllen.

    Komplexität

    Genau last - first Vergleiche/Anwendungen des Prädikats und die gleiche Anzahl von Anwendungen der Projektion.

    Hinweise

    Für die Anzahl der Elemente im Bereich [ first , last ) ohne zusätzliche Kriterien, siehe ranges::distance .

    Mögliche Implementierung

    Erste Version 
    template<InputIterator I, Sentinel<I> S, class T, class Proj = ranges::identity>
    requires IndirectRelation<ranges::equal_to<>, projected<I, Proj>, const T*>
ranges::difference_type_t<I> count(I first, S last, const T& value, Proj proj = Proj{})
{
    ranges::difference_type_t<I> ret = 0;
    for (; first != last; ++first)
        if (ranges::invoke(proj, *first) == value)
            ++ret;
    return ret;
}
    Zweite Version 
    template<InputIterator I, Sentinel<I> S, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
ranges::difference_type_t<I> count_if(I first, S last, Pred pred, Proj proj = Proj{})
{
    ranges::difference_type_t<I> ret = 0;
    for (; first != last; ++first)
        if (ranges::invoke(pred, ranges::invoke(proj, *i)))
            ++ret;
    return ret;
}

    Beispiel

    Dieser Abschnitt ist unvollständig
    Grund: Kein Beispiel

    Siehe auch

    		 gibt die Anzahl der Elemente zurück, die bestimmte Kriterien erfüllen
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)(C++20)
    		gibt den Abstand zwischen einem Iterator und einem Sentinel oder zwischen dem Anfang und dem Ende eines Bereichs zurück
    (Funktionsschablone)