Namespaces
Variants
Views
Actions

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

From cppreference.com
< cpp‎ | algorithm‎ | ranges
m (→‎Complexity: mathjax-or)
m (→‎Example: fmt a bit)
Line 93: Line 93:
 
  |
 
  |
 
  | 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 "? true\n"; }
 +
    std::string do_falsename() const { return "? false\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'},
−
  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 } ? true
−
a b c   : true
+
{ a c } ? true
−
a c     : true
+
{ a a b } ? false
−
a a b   : false
+
{ g } ? false
−
g       : false
+
{ a c g } ? false
−
a c g   : false
+
{ A B C } ? true
−
A B C   : true (case-insensitive)
+
 
}}
 
}}
  

Revision as of 04:46, 11 July 2022

 
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

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

Return value

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

Complexity

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

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

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 "? true\n"; }
    std::string do_falsename() const { return "? false\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 } ? true
{ a c } ? true
{ a a b } ? false
{ g } ? false
{ a c g } ? false
{ A B C } ? true

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]
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=140931"