Namespaces
Variants

std::ranges:: includes

From cppreference.net
C++
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy , ranges::sort , ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
Modifying sequence operations
Copy operations
(C++11)
(C++11)
(C++11)
Swap operations
Transformation operations
Generation operations
Removing operations
Order-changing operations
(until C++17) (C++11)
(C++20) (C++20)
Sampling operations
(C++17)

Sorting and related operations
Partitioning operations
Sorting operations
Binary search operations
(on partitioned ranges)
Set operations (on sorted ranges)
Merge operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Lexicographical comparison operations
(C++20)
Permutation operations
C library
Numeric operations
Operations on uninitialized memory
Constrained algorithms
All names in this menu belong to namespace std::ranges
Non-modifying sequence operations
Modifying sequence operations
Partitioning operations
Sorting operations
Binary search operations (on sorted ranges)
Set operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Permutation operations
Fold operations
Operations on uninitialized storage
Return types
Definiert im Header <algorithm>
Aufrufsignatur
template < std:: input_iterator I1, std:: sentinel_for < I1 > S1,

std:: input_iterator I2, std:: sentinel_for < I2 > S2,
class Proj1 = std:: identity , class Proj2 = std:: identity ,
std:: indirect_strict_weak_order <
std :: projected < I1, Proj1 > ,
std :: projected < I2, Proj2 >> Comp = ranges:: less >
constexpr bool
includes ( I1 first1, S1 last1, I2 first2, S2 last2,

Comp comp = { } , Proj1 proj1 = { } , Proj2 proj2 = { } )
(1) (seit C++20)
template < ranges:: input_range R1, ranges:: input_range R2,

class Proj1 = std:: identity , class Proj2 = std:: identity ,
std:: indirect_strict_weak_order <
std :: projected < ranges:: iterator_t < R1 > , Proj1 > ,
std :: projected < ranges:: iterator_t < R2 > , Proj2 >> Comp = ranges:: less >
constexpr bool

includes ( R1 && r1, R2 && r2, Comp comp = { } , Proj1 proj1 = { } , Proj2 proj2 = { } )
(2) (seit C++20)
1) Gibt true zurück, falls die Projektionen des sortierten Bereichs [ first2 , last2 ) eine Teilfolge der Projektionen des sortierten Bereichs [ first1 , last1 ) sind.
2) Gleich wie (1) , verwendet jedoch r1 und r2 als Quellbereiche, als ob ranges:: begin ( r1 ) und ranges:: begin ( r2 ) als first1 bzw. first2 verwendet würden, und ranges:: end ( r1 ) und ranges:: end ( r2 ) als last1 bzw. last2 .

Beide Bereiche müssen mit der angegebenen Vergleichsfunktion comp sortiert sein. Eine Teilsequenz muss nicht zusammenhängend sein.

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

Inhaltsverzeichnis

Parameter

first1, last1 - das Iterator-Sentinel-Paar, das den sortierten Bereich der zu untersuchenden Elemente definiert
r1 - der sortierte Bereich der zu untersuchenden Elemente
first2, last2 - das Iterator-Sentinel-Paar, das den sortierten Bereich der zu suchenden Elemente definiert
r2 - der sortierte Bereich der zu suchenden Elemente
comp - Vergleichsfunktion, die auf die projizierten Elemente angewendet wird
proj1 - Projektion, die auf die Elemente im ersten Bereich angewendet wird
proj2 - Projektion, die auf die Elemente im zweiten Bereich angewendet wird

Rückgabewert

true falls [ first2 , last2 ) eine Teilfolge von [ first1 , last1 ) ist; andernfalls false .

Komplexität

Höchstens 2·(N 1 +N 2 -1) Vergleiche, wobei N 1 gleich ranges:: distance ( r1 ) und N 2 gleich ranges:: distance ( r2 ) ist.

Mögliche Implementierung 

struct includes_fn
{
    template<std::input_iterator I1, std::sentinel_for<I1> S1,
             std::input_iterator I2, std::sentinel_for<I2> S2,
             class Proj1 = std::identity, class Proj2 = std::identity,
             std::indirect_strict_weak_order<
                 std::projected<I1, Proj1>,
                 std::projected<I2, Proj2>> Comp = ranges::less>
    constexpr bool operator()(I1 first1, S1 last1, I2 first2, S2 last2,
                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        for (; first2 != last2; ++first1)
        {
            if (first1 == last1 || comp(*first2, *first1))
                return false;
            if (!comp(*first1, *first2))
                ++first2;
        }
        return true;
    }
    template<ranges::input_range R1, ranges::input_range R2,
             class Proj1 = std::identity, class Proj2 = std::identity,
             std::indirect_strict_weak_order<
                 std::projected<ranges::iterator_t<R1>, Proj1>,
                 std::projected<ranges::iterator_t<R2>, Proj2>> Comp = ranges::less>
    constexpr bool operator()(R1&& r1, R2&& r2, Comp comp = {},
                              Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        return (*this)(ranges::begin(r1), ranges::end(r1),
                       ranges::begin(r2), ranges::end(r2),
                       std::ref(comp), std::ref(proj1), std::ref(proj2));
    }
};
inline constexpr auto includes = includes_fn {};

Beispiel

Diesen Code ausführen 
#include <algorithm>
#include <cctype>
#include <initializer_list>
#include <iomanip>
#include <iostream>
#include <locale>
#include <string>
template<class T>
std::ostream& operator<<(std::ostream& os, std::initializer_list<T> const& list)
{
    for (os << "{ "; auto const& elem : list)
        os << elem << ' ';
    return os << "} ";
}
struct true_false : std::numpunct<char>
{
    std::string do_truename() const { return "? Yes\n"; }
    std::string do_falsename() const { return "? No\n"; }
};
int main()
{
    std::cout.imbue(std::locale(std::cout.getloc(), new true_false));
    auto ignore_case = [](char a, char b) { return std::tolower(a) < std::tolower(b); };
    const auto
        a = {'a', 'b', 'c'},
        b = {'a', 'c'},
        c = {'a', 'a', 'b'},
        d = {'g'},
        e = {'a', 'c', 'g'},
        f = {'A', 'B', 'C'},
        z = {'a', 'b', 'c', 'f', 'h', 'x'};
    std::cout
        << z << "enthält\n" << std::boolalpha
        << a << std::ranges::includes(z.begin(), z.end(), a.begin(), a.end())
        << b << std::ranges::includes(z, b)
        << c << std::ranges::includes(z, c)
        << d << std::ranges::includes(z, d)
        << e << std::ranges::includes(z, e)
        << f << std::ranges::includes(z, f, ignore_case);
}

Ausgabe: 

{ a b c f h x } enthält
{ a b c } ? Yes
{ a c } ? Yes
{ a a b } ? No
{ g } ? No
{ a c g } ? No
{ A B C } ? Yes
**Übersetzungshinweise:** - "Run this code" → "Diesen Code ausführen" (professionelle Übersetzung für Code-Ausführung) - "includes" → "enthält" (passende Übersetzung für den Algorithmus-Kontext) - "Output" → "Ausgabe" (Standardübersetzung in der Programmierung) - HTML-Tags, Attribute und Code-Blöcke wurden unverändert belassen - C++-spezifische Begriffe (wie Funktionsnamen, Typen) wurden nicht übersetzt - Die Formatierung und Struktur der Webseite wurde vollständig beibehalten

Siehe auch

(C++20)
berechnet die Differenz zwischen zwei Mengen
(Algorithmus-Funktionsobjekt)
(C++20)
sucht nach dem ersten Vorkommen eines Elementbereichs
(Algorithmus-Funktionsobjekt)
(C++23) (C++23)
prüft, ob der Bereich das gegebene Element oder den Teilbereich enthält
(Algorithmus-Funktionsobjekt)
gibt true zurück, falls eine Sequenz eine Teilsequenz einer anderen ist
(Funktionstemplate)