std::ranges:: find_last, std::ranges:: find_last_if, std::ranges:: find_last_if_not

From cppreference.net

(Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Gemäß den Anforderungen wurden die HTML-Tags und Attribute unverändert beibehalten.)

Definiert im Header `<algorithm>`
Aufrufsignatur
	(1)
template < std:: forward_iterator I, std:: sentinel_for < I > S, class T, class Proj = std:: identity > requires std:: indirect_binary_predicate < ranges:: equal_to , std :: projected < I, Proj > , const T * > constexpr ranges:: subrange < I > find_last ( I first, S last, const T & value, Proj proj = { } ) ;			(seit C++23) (bis C++26)
template < std:: forward_iterator I, std:: sentinel_for < I > S, class Proj = std:: identity , class T = std :: projected_value_t < I, Proj > > requires std:: indirect_binary_predicate < ranges:: equal_to , std :: projected < I, Proj > , const T * > constexpr ranges:: subrange < I > find_last ( I first, S last, const T & value, Proj proj = { } ) ;			(seit C++26)
		(2)
template < ranges:: forward_range R, class T, class Proj = std:: identity > requires std:: indirect_binary_predicate < ranges:: equal_to , std :: projected < ranges:: iterator_t < R > , Proj > , const T * > constexpr ranges:: borrowed_subrange_t < R > find_last ( R && r, const T & value, Proj proj = { } ) ;				(seit C++23) (bis C++26)
template < ranges:: forward_range R, class Proj = std:: identity , class T = std :: projected_value_t < iterator_t < R > , Proj > > requires std:: indirect_binary_predicate < ranges:: equal_to , std :: projected < ranges:: iterator_t < R > , Proj > , const T * > constexpr ranges:: borrowed_subrange_t < R > find_last ( R && r, const T & value, Proj proj = { } ) ;				(seit C++26)
template < std:: forward_iterator I, std:: sentinel_for < I > S, class Proj = std:: identity , std:: indirect_unary_predicate < std :: projected < I, Proj >> Pred > constexpr ranges:: subrange < I > find_last_if ( I first, S last, Pred pred, Proj proj = { } ) ;			(3)	(seit C++23)
template < ranges:: forward_range R, class Proj = std:: identity , std:: indirect_unary_predicate < std :: projected < ranges:: iterator_t < R > , Proj >> Pred > constexpr ranges:: borrowed_subrange_t < R > find_last_if ( R && r, Pred pred, Proj proj = { } ) ;			(4)	(seit C++23)
template < std:: forward_iterator I, std:: sentinel_for < I > S, class Proj = std:: identity , std:: indirect_unary_predicate < std :: projected < I, Proj >> Pred > constexpr ranges:: subrange < I > find_last_if_not ( I first, S last, Pred pred, Proj proj = { } ) ;			(5)	(seit C++23)
template < ranges:: forward_range R, class Proj = std:: identity , std:: indirect_unary_predicate < std :: projected < ranges:: iterator_t < R > , Proj >> Pred > constexpr ranges:: borrowed_subrange_t < R > find_last_if_not ( R && r, Pred pred, Proj proj = { } ) ;			(6)	(seit C++23)

Gibt das letzte Element im Bereich [ first , last ) zurück, das bestimmte Kriterien erfüllt:


        find_last

sucht nach einem Element, das gleich value ist.


        find_last_if

sucht nach dem letzten Element im Bereich

first

last

für das Prädikat pred den Wert true zurückgibt.


        find_last_if_not

sucht nach dem letzten Element im Bereich

first

last

für das Prädikat pred den Wert false zurückgibt.

2,4,6) Gleich wie (1,3,5) , verwendet jedoch r als Quellbereich, als ob ranges:: begin ( r ) als first und ranges:: end ( r ) als last verwendet würde.

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithm Function Objects (informell bekannt als Niebloids ), das heißt:

Explizite Template-Argumentlisten können beim Aufruf keiner von ihnen angegeben werden.
Keiner von ihnen ist sichtbar für argument-dependent lookup .
Wenn einer von ihnen durch normal unqualified lookup als Name links vom Funktionsaufrufoperator gefunden wird, wird argument-dependent lookup unterdrückt.

Inhaltsverzeichnis

Parameter

first, last	-	das Iterator-Sentinel-Paar, das den Bereich der zu untersuchenden Elemente definiert
r	-	der Bereich der zu untersuchenden Elemente
value	-	Wert, mit dem die Elemente verglichen werden
pred	-	Prädikat, das auf die projizierten Elemente angewendet wird
proj	-	Projektion, die auf die Elemente angewendet wird

Rückgabewert

1,3,5) Sei i der letzte Iterator im Bereich

first

last

für den E true ist.

Gibt ranges:: subrange < I > { i, last } zurück, oder ranges:: subrange < I > { last, last } falls kein solcher Iterator gefunden wird.

1) E ist bool ( std:: invoke ( proj, * i ) == value ) .

3) E ist bool ( std:: invoke ( pred, std:: invoke ( proj, * i ) ) ) .

5) E ist bool ( ! std:: invoke ( pred, std:: invoke ( proj, * i ) ) ) .

2,4,6) Gleich wie (1,3,5) aber der Rückgabetyp ist ranges:: borrowed_subrange_t < I > .

Komplexität

Höchstens last - first Anwendungen des Prädikats und der Projektion.

Hinweise

ranges::find_last , ranges::find_last_if , ranges::find_last_if_not weisen auf gängigen Implementierungen eine bessere Effizienz auf, falls I das bidirectional_iterator oder (besser noch) das random_access_iterator modelliert.

Feature-Test Makro	Wert	Std	Funktion
`__cpp_lib_ranges_find_last`	`202207L`	(C++23)	`ranges::find_last` , `ranges::find_last_if` , `ranges::find_last_if_not`
`__cpp_lib_algorithm_default_value_type`	`202403L`	(C++26)	Listeninitialisierung für Algorithmen ( 1,2 )

Mögliche Implementierung

Diese Implementierungen zeigen nur den langsameren Algorithmus, der verwendet wird, wenn I das Konzept forward_iterator modelliert.

find_last (1,2)
struct find_last_fn { template<std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity, class T = std::projected_value_t<iterator_t<R>, Proj>> requires std::indirect_binary_predicate <ranges::equal_to, std::projected<I, Proj>, const T> constexpr ranges::subrange<I> operator()(I first, S last, const T &value, Proj proj = {}) const { // Hinweis: Wenn I nur ein Forward-Iterator ist, können wir nur von Anfang bis Ende gehen. std::optional<I> found; for (; first != last; ++first) if (std::invoke(proj, first) == value) found = first; if (!found) return {first, first}; return {found, std::ranges::next(found, last)}; } template<ranges::forward_range R, class Proj = std::identity, class T = std::projected_value_t<iterator_t<R>, Proj>> requires std::indirect_binary_predicate <ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*> constexpr ranges::borrowed_subrange_t<R> operator()(R&& r, const T &value, Proj proj = {}) const { return this->operator()(ranges::begin(r), ranges::end(r), value, std::ref(proj)); } }; inline constexpr find_last_fn find_last;
find_last_if (3,4)
struct find_last_if_fn { template<std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred> constexpr ranges::subrange<I> operator()(I first, S last, Pred pred, Proj proj = {}) const { // Hinweis: Wenn I nur ein Forward-Iterator ist, können wir nur von Anfang bis Ende gehen. std::optional<I> found; for (; first != last; ++first) if (std::invoke(pred, std::invoke(proj, first))) found = first; if (!found) return {first, first}; return {found, std::ranges::next(*found, last)}; } template<ranges::forward_range R, class Proj = std::identity, std::indirect_unary_predicate <std::projected<ranges::iterator_t<R>, Proj>> Pred> constexpr ranges::borrowed_subrange_t<R> operator()(R&& r, Pred pred, Proj proj = {}) const { return this->operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj)); } }; inline constexpr find_last_if_fn find_last_if;
find_last_if_not (5,6)
struct find_last_if_not_fn { template<std::forward_iterator I, std::sentinel_for<I> S, class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred> constexpr ranges::subrange<I> operator()(I first, S last, Pred pred, Proj proj = {}) const { // Hinweis: Wenn I nur ein Forward-Iterator ist, können wir nur von Anfang bis Ende gehen. std::optional<I> found; for (; first != last; ++first) if (!std::invoke(pred, std::invoke(proj, first))) found = first; if (!found) return {first, first}; return {found, std::ranges::next(*found, last)}; } template<ranges::forward_range R, class Proj = std::identity, std::indirect_unary_predicate <std::projected<ranges::iterator_t<R>, Proj>> Pred> constexpr ranges::borrowed_subrange_t<R> operator()(R&& r, Pred pred, Proj proj = {}) const { return this->operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj)); } }; inline constexpr find_last_if_not_fn find_last_if_not;

Beispiel

Diesen Code ausführen

#include <algorithm>
#include <cassert>
#include <forward_list>
#include <iomanip>
#include <iostream>
#include <string_view>
int main()
{
    namespace ranges = std::ranges;
    constexpr static auto v = {1, 2, 3, 1, 2, 3, 1, 2};
    {
        constexpr auto i1 = ranges::find_last(v.begin(), v.end(), 3);
        constexpr auto i2 = ranges::find_last(v, 3);
        static_assert(ranges::distance(v.begin(), i1.begin()) == 5);
        static_assert(ranges::distance(v.begin(), i2.begin()) == 5);
    }
    {
        constexpr auto i1 = ranges::find_last(v.begin(), v.end(), -3);
        constexpr auto i2 = ranges::find_last(v, -3);
        static_assert(i1.begin() == v.end());
        static_assert(i2.begin() == v.end());
    }
    auto abs = [](int x) { return x < 0 ? -x : x; };
    {
        auto pred = [](int x) { return x == 3; };
        constexpr auto i1 = ranges::find_last_if(v.begin(), v.end(), pred, abs);
        constexpr auto i2 = ranges::find_last_if(v, pred, abs);
        static_assert(ranges::distance(v.begin(), i1.begin()) == 5);
        static_assert(ranges::distance(v.begin(), i2.begin()) == 5);
    }
    {
        auto pred = [](int x) { return x == -3; };
        constexpr auto i1 = ranges::find_last_if(v.begin(), v.end(), pred, abs);
        constexpr auto i2 = ranges::find_last_if(v, pred, abs);
        static_assert(i1.begin() == v.end());
        static_assert(i2.begin() == v.end());
    }
    {
        auto pred = [](int x) { return x == 1 or x == 2; };
        constexpr auto i1 = ranges::find_last_if_not(v.begin(), v.end(), pred, abs);
        constexpr auto i2 = ranges::find_last_if_not(v, pred, abs);
        static_assert(ranges::distance(v.begin(), i1.begin()) == 5);
        static_assert(ranges::distance(v.begin(), i2.begin()) == 5);
    }
    {
        auto pred = [](int x) { return x == 1 or x == 2 or x == 3; };
        constexpr auto i1 = ranges::find_last_if_not(v.begin(), v.end(), pred, abs);
        constexpr auto i2 = ranges::find_last_if_not(v, pred, abs);
        static_assert(i1.begin() == v.end());
        static_assert(i2.begin() == v.end());
    }
    using P = std::pair<std::string_view, int>;
    std::forward_list<P> list
    {
        {"eins", 1}, {"zwei", 2}, {"drei", 3},
        {"eins", 4}, {"zwei", 5}, {"drei", 6},
    };
    auto cmp_one = [](const std::string_view &s) { return s == "eins"; };
    // find latest element that satisfy the comparator, and projecting pair::first
    const auto subrange = ranges::find_last_if(list, cmp_one, &P::erste);
    std::cout << "Das gefundene Element und der Rest danach sind:\n";
    for (P const& e : subrange)
        std::cout << '{' << std::quoted(e.first) << ", " << e.second << "} ";
    std::cout << '\n';
#if __cpp_lib_algorithm_default_value_type
    const auto i3 = ranges::find_last(list, {"drei", 3}); // (2) C++26
#else
    const auto i3 = ranges::find_last(list, P{"drei", 3}); // (2) C++23
#endif
    assert(i3.begin()->first == "drei" && i3.begin()->second == 3);
}

Ausgabe:

Das gefundene Element und der Rest danach sind:
{"one", 4} {"two", 5} {"three", 6}

Siehe auch

ranges::find_end (C++20)	findet die letzte Sequenz von Elementen in einem bestimmten Bereich (Algorithmus-Funktionsobjekt)
ranges::find ranges::find_if ranges::find_if_not (C++20) (C++20) (C++20)	findet das erste Element, das bestimmte Kriterien erfüllt (Algorithmus-Funktionsobjekt)
ranges::search (C++20)	sucht nach dem ersten Vorkommen eines Bereichs von Elementen (Algorithmus-Funktionsobjekt)
ranges::includes (C++20)	gibt true zurück, wenn eine Sequenz eine Teilsequenz einer anderen ist (Algorithmus-Funktionsobjekt)
ranges::binary_search (C++20)	bestimmt, ob ein Element in einem teilweise geordneten Bereich existiert (Algorithmus-Funktionsobjekt)
ranges::contains ranges::contains_subrange (C++23) (C++23)	prüft, ob der Bereich das gegebene Element oder den Teilbereich enthält (Algorithmus-Funktionsobjekt)

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

std::ranges:: find_last, std::ranges:: find_last_if, std::ranges:: find_last_if_not

Inhaltsverzeichnis

Parameter

Rückgabewert

Komplexität

Hinweise

Mögliche Implementierung

Beispiel

Siehe auch