Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/algorithm/ranges/includes"

From cppreference.com
< cpp‎ | algorithm‎ | ranges
m (→‎Example)
 
(8 intermediate revisions by 4 users not shown)
Line 2: Line 2:
 
{{cpp/algorithm/ranges/navbar}}
 
{{cpp/algorithm/ranges/navbar}}
 
{{dcl begin}}
 
{{dcl begin}}
−
{{dcl header | algorithm}}
+
{{dcl header|algorithm}}
−
{{dcl h | Call signature}}
+
{{dcl h|Call signature}}
−
{{dcl | num=1 | since=c++20 |1=
+
{{dcl|num=1|since=c++20|1=
 
template< std::input_iterator I1, std::sentinel_for<I1> S1,
 
template< std::input_iterator I1, std::sentinel_for<I1> S1,
 
           std::input_iterator I2, std::sentinel_for<I2> S2,
 
           std::input_iterator I2, std::sentinel_for<I2> S2,
Line 11: Line 11:
 
               std::projected<I1, Proj1>,
 
               std::projected<I1, Proj1>,
 
               std::projected<I2, Proj2>> Comp = ranges::less >
 
               std::projected<I2, Proj2>> Comp = ranges::less >
−
constexpr bool includes( I1 first1, S1 last1, I2 first2, S2 last2,
+
constexpr bool
−
                        Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {} )
+
    includes( I1 first1, S1 last1, I2 first2, S2 last2,
 +
              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {} )
 
}}
 
}}
−
{{dcl | num=2 | since=c++20 |1=
+
{{dcl|num=2|since=c++20|1=
 
template< ranges::input_range R1, ranges::input_range R2,
 
template< ranges::input_range R1, ranges::input_range R2,
 
           class Proj1 = std::identity, class Proj2 = std::identity,
 
           class Proj1 = std::identity, class Proj2 = std::identity,
Line 20: Line 21:
 
               std::projected<ranges::iterator_t<R1>, Proj1>,
 
               std::projected<ranges::iterator_t<R1>, Proj1>,
 
               std::projected<ranges::iterator_t<R2>, Proj2>> Comp = ranges::less >
 
               std::projected<ranges::iterator_t<R2>, Proj2>> Comp = ranges::less >
−
constexpr bool includes( R1&& r1, R2&& r2, Comp comp = {},
+
constexpr bool
−
                        Proj1 proj1 = {}, Proj2 proj2 = {} )
+
    includes( R1&& r1, R2&& r2, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {} )
 
}}
 
}}
 
{{dcl end}}
 
{{dcl end}}
  
−
@1@ Returns {{c|true}} if the projections of the sorted range {{tt|[first2, last2)}} is a {{enwiki|subsequence}} of the projections of the sorted range {{tt|[first1, last1)}}.
+
@1@ Returns {{c|true}} if the projections of the sorted range {{range|first2|last2}} is a {{enwiki|subsequence}} of the projections of the sorted range {{range|first1|last1}}.
−
@2@ Same as {{v|1}}, but uses {{tt|r1}} and {{tt|r2}} as the source ranges, as if by using {{c|ranges::begin(r1)}} and {{c|ranges::begin(r2)}} as {{tt|first1}} and {{tt|first2}} respectively, and {{c|ranges::end(r1)}} and {{c|ranges::end(r2)}} as {{tt|last1}} and {{tt|last2}} respectively.
+
@2@ Same as {{v|1}}, but uses {{c|r1}} and {{c|r2}} as the source ranges, as if by using {{c|ranges::begin(r1)}} and {{c|ranges::begin(r2)}} as {{c|first1}} and {{c|first2}} respectively, and {{c|ranges::end(r1)}} and {{c|ranges::end(r2)}} as {{c|last1}} and {{c|last2}} respectively.
  
−
Both ranges must be sorted with the given comparison function {{tt|comp}}. A subsequence need not be contiguous.
+
Both ranges must be sorted with the given comparison function {{c|comp}}. A subsequence need not be contiguous.
  
 
{{cpp/ranges/niebloid}}
 
{{cpp/ranges/niebloid}}
Line 34: Line 35:
 
===Parameters===
 
===Parameters===
 
{{par begin}}
 
{{par begin}}
−
{{par | first1, last1 | the sorted range of elements to examine}}
+
{{par|first1, last1|the sorted range of elements to examine}}
−
{{par | r1 | the sorted range of elements to examine}}
+
{{par|r1|the sorted range of elements to examine}}
−
{{par | first2, last2 | the sorted range of elements to search for}}
+
{{par|first2, last2|the sorted range of elements to search for}}
−
{{par | r2 | the sorted range of elements to search for}}
+
{{par|r2|the sorted range of elements to search for}}
−
{{par | comp | comparison function to apply to the projected elements}}
+
{{par|comp|comparison function to apply to the projected elements}}
−
{{par | proj1 | projection to apply to the elements in the first range}}
+
{{par|proj1|projection to apply to the elements in the first range}}
−
{{par | proj2 | projection to apply to the elements in the second range}}
+
{{par|proj2|projection to apply to the elements in the second range}}
 
{{par end}}
 
{{par end}}
  
 
===Return value===
 
===Return value===
−
{{c|true}} if {{tt|[first2, last2)}} is a subsequence of {{tt|[first1, last1)}}; otherwise {{c|false}}.
+
{{c|true}} if {{range|first2|last2}} is a subsequence of {{range|first1|last1}}; otherwise {{c|false}}.
  
 
===Complexity===
 
===Complexity===
−
At most {{math|2&middot;(N<sub>1</sub>+N<sub>2</sub>-1)}} comparisons, where {{math|N<sub>1</sub>}} {{c|{{=}} ranges::distance(r1)}} and {{math|N<sub>2</sub>}} {{c|{{=}} ranges::distance(r2)}}.
+
At most {{mathjax-or|\(\scriptsize 2 \cdot (N_1+N_2-1)\)|2&middot;(N<sub>1</sub>+N<sub>2</sub>-1)}} comparisons, where {{mathjax-or|\(\scriptsize N_1\)|N<sub>1</sub>}} is {{c|ranges::distance(r1)}} and {{mathjax-or|\(\scriptsize N_2\)|N<sub>2</sub>}} is {{c|ranges::distance(r2)}}.
  
 
===Possible implementation===
 
===Possible implementation===
 
{{eq fun
 
{{eq fun
−
| 1=
+
|1=
−
struct includes_fn {
+
struct includes_fn
−
  template<std::input_iterator I1, std::sentinel_for<I1> S1,
+
{
−
          std::input_iterator I2, std::sentinel_for<I2> S2,
+
    template<std::input_iterator I1, std::sentinel_for<I1> S1,
−
          class Proj1 = std::identity, class Proj2 = std::identity,
+
            std::input_iterator I2, std::sentinel_for<I2> S2,
−
          std::indirect_strict_weak_order<
+
            class Proj1 = std::identity, class Proj2 = std::identity,
−
              std::projected<I1, Proj1>,
+
            std::indirect_strict_weak_order<
−
              std::projected<I2, Proj2>> Comp = ranges::less>
+
                std::projected<I1, Proj1>,
−
  constexpr bool operator()(I1 first1, S1 last1, I2 first2, S2 last2,
+
                std::projected<I2, Proj2>> Comp = ranges::less>
−
                          Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const
+
    constexpr bool operator()(I1 first1, S1 last1, I2 first2, S2 last2,
−
  {
+
                              Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const
−
      for (; first2 != last2; ++first1)
+
    {
−
      {
+
        for (; first2 != last2; ++first1)
−
          if (first1 == last1 && comp(*first2, *first1))
+
        {
−
              return false;
+
            if (first1 == last1 {{!!}} comp(*first2, *first1))
−
          if (!comp(*first1, *first2))
+
                return false;
−
              ++first2;
+
            if (!comp(*first1, *first2))
−
      }
+
                ++first2;
−
      return true;
+
        }
−
  }
+
        return true;
 +
    }
  
−
  template<ranges::input_range R1, ranges::input_range R2,
+
    template<ranges::input_range R1, ranges::input_range R2,
−
          class Proj1 = std::identity, class Proj2 = std::identity,
+
            class Proj1 = std::identity, class Proj2 = std::identity,
−
          std::indirect_strict_weak_order<
+
            std::indirect_strict_weak_order<
−
              std::projected<ranges::iterator_t<R1>, Proj1>,
+
                std::projected<ranges::iterator_t<R1>, Proj1>,
−
              std::projected<ranges::iterator_t<R2>, Proj2>> Comp = ranges::less>
+
                std::projected<ranges::iterator_t<R2>, Proj2>> Comp = ranges::less>
−
  constexpr bool operator()(R1&& r1, R2&& r2, Comp comp = {},
+
    constexpr bool operator()(R1&& r1, R2&& r2, Comp comp = {},
−
                            Proj1 proj1 = {}, Proj2 proj2 = {}) const
+
                              Proj1 proj1 = {}, Proj2 proj2 = {}) const
−
  {
+
    {
−
    return (*this)(ranges::begin(r1), ranges::end(r1),
+
        return (*this)(ranges::begin(r1), ranges::end(r1),
−
                  ranges::begin(r2), ranges::end(r2),
+
                      ranges::begin(r2), ranges::end(r2),
−
                  std::ref(comp), std::ref(proj1), std::ref(proj2));
+
                      std::ref(comp), std::ref(proj1), std::ref(proj2));
−
  }
+
    }
 
};
 
};
  
−
inline constexpr auto includes = includes_fn{};
+
inline constexpr auto includes = includes_fn {};
 
}}
 
}}
  
 
===Example===
 
===Example===
 
{{example
 
{{example
−
|
+
|
−
| code=
+
|code=
−
#include <iostream>
+
 
#include <algorithm>
 
#include <algorithm>
 
#include <cctype>
 
#include <cctype>
 +
#include <initializer_list>
 +
#include <iomanip>
 +
#include <iostream>
 +
#include <locale>
 +
#include <string>
  
−
template <class Os, class R> Os& operator<<(Os& os, const R& r) {
+
template<class T>
−
  for (const auto& e : r) os << e << ' ';
+
std::ostream& operator<<(std::ostream& os, std::initializer_list<T> const& list)
−
  return os << '\t';
+
{
 +
    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()
 
int main()
 
{
 
{
−
  const auto
+
    std::cout.imbue(std::locale(std::cout.getloc(), new true_false));
−
     v1 = {'a', 'b', 'c', 'f', 'h', 'x'},
+
 
−
     v2 = {'a', 'b', 'c'},
+
     auto ignore_case = [](char a, char b) { return std::tolower(a) < std::tolower(b); };
−
    v3 = {'a', 'c'},
+
 
−
    v4 = {'a', 'a', 'b'},
+
     const auto
−
    v5 = {'g'},
+
        a = {'a', 'b', 'c'},
−
    v6 = {'a', 'c', 'g'},
+
        b = {'a', 'c'},
−
    v7 = {'A', 'B', 'C'};
+
        c = {'a', 'a', 'b'},
−
+
        d = {'g'},
−
  auto no_case = [](char a, char b) { return std::tolower(a) < std::tolower(b); };
+
        e = {'a', 'c', 'g'},
−
  using namespace ranges = std::ranges;
+
        f = {'A', 'B', 'C'},
−
  std::cout
+
        z = {'a', 'b', 'c', 'f', 'h', 'x'};
−
    << v1 << "\nincludes:\n" << std::boolalpha
+
 
−
    << v2 << ": " << ranges::includes(v1.begin(), v1.end(), v2.begin(), v2.end()) << '\n'
+
    std::cout
−
    << v3 << ": " << ranges::includes(v1, v3) << '\n'
+
        << z << "includes\n" << std::boolalpha
−
    << v4 << ": " << ranges::includes(v1, v4) << '\n'
+
        << a << std::ranges::includes(z.begin(), z.end(), a.begin(), a.end())
−
    << v5 << ": " << ranges::includes(v1, v5) << '\n'
+
        << b << std::ranges::includes(z, b)
−
    << v6 << ": " << ranges::includes(v1, v6) << '\n'
+
        << c << std::ranges::includes(z, c)
−
    << v7 << ": " << ranges::includes(v1, v7, no_case)
+
        << d << std::ranges::includes(z, d)
−
          << " (case-insensitive)\n";
+
        << e << std::ranges::includes(z, e)
 +
        << f << std::ranges::includes(z, f, ignore_case);
 
}
 
}
−
| output=
+
|output=
−
a b c f h x  
+
{ a b c f h x } includes
−
includes:
+
{ a b c } ? Yes
−
a b c   : true
+
{ a c } ? Yes
−
a c     : true
+
{ a a b } ? No
−
a a b   : false
+
{ g } ? No
−
g       : false
+
{ a c g } ? No
−
a c g   : false
+
{ A B C } ? Yes
−
A B C   : true (case-insensitive)
+
 
}}
 
}}
  
 
===See also===
 
===See also===
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc inc | cpp/algorithm/ranges/dsc set_difference}}
+
{{dsc inc|cpp/algorithm/ranges/dsc set_difference}}
−
{{dsc inc | cpp/algorithm/ranges/dsc search}}
+
{{dsc inc|cpp/algorithm/ranges/dsc search}}
−
{{dsc inc | cpp/algorithm/dsc includes}}
+
{{dsc inc|cpp/algorithm/ranges/dsc contains}}
 +
{{dsc inc|cpp/algorithm/dsc includes}}
 
{{dsc end}}
 
{{dsc end}}
  
 
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}
 
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}

Latest revision as of 11:59, 18 July 2023

 
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
(C++11)                (C++11)(C++11)

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
(C++11)
(C++17)
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
Numeric operations
(C++23)            
Operations on uninitialized storage
Return types
 
Defined in header <algorithm>
Call signature
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) (since 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) (since C++20)
1) Returns true if the projections of the sorted range [first2, last2) is a subsequence of the projections of the sorted range [first1, last1).
2) Same as (1), but uses r1 and r2 as the source ranges, as if by using ranges::begin(r1) and ranges::begin(r2) as first1 and first2 respectively, and ranges::end(r1) and ranges::end(r2) as last1 and last2 respectively.

Both ranges must be sorted with the given comparison function comp. A subsequence need not be contiguous.

The function-like entities described on this page are niebloids, that is:

In practice, they may be implemented as function objects, or with special compiler extensions.

Contents

[edit] Parameters

first1, last1 - the sorted range of elements to examine
r1 - the sorted range of elements to examine
first2, last2 - the sorted range of elements to search for
r2 - the sorted range of elements to search for
comp - comparison function to apply to the projected elements
proj1 - projection to apply to the elements in the first range
proj2 - projection to apply to the elements in the second range

[edit] Return value

true if [first2, last2) is a subsequence of [first1, last1); otherwise false.

[edit] Complexity

At most 2·(N1+N2-1) comparisons, where N1 is ranges::distance(r1) and N2 is ranges::distance(r2).

[edit] Possible implementation

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 {};

[edit] Example

Run this code
#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 << "includes\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);
}

Output: 

{ a b c f h x } includes
{ a b c } ? Yes
{ a c } ? Yes
{ a a b } ? No
{ g } ? No
{ a c g } ? No
{ A B C } ? Yes

[edit] See also

(C++20)
 computes the difference between two sets
(niebloid)[edit]
(C++20)
 searches for the first occurrence of a range of elements
(niebloid)[edit]
(C++23)(C++23)
 checks if the range contains the given element or subrange
(niebloid)[edit]
returns true if one sequence is a subsequence of another
(function template) [edit]
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/ranges/includes&oldid=155059"