Espacios de nombres
Variantes
Acciones

std::includes

De cppreference.com
< cpp‎ | algorithm

 
 
Biblioteca de algoritmos
Políticas de ejecución (C++17)
Operaciones no modificadoras de secuencia
(C++11)(C++11)(C++11)
(C++17)
Operaciones modificadoras de secuencia
Operaciones en almacenamiento no inicializado
Operaciones de partición
Operaciones de ordenación
(C++11)
Operaciones de búsqueda binaria
Operaciones de set (en rangos ordenados)
includes

Operaciones de pila
(C++11)
Operaciones minimo/maximo
(C++11)
(C++17)
Permutaciones
Operaciones numéricas
Bibliotecas C
 
Definido en la cabecera <algorithm>
template< class InputIt1, class InputIt2 >

bool includes( InputIt1 first1, InputIt1 last1,

               InputIt2 first2, InputIt2 last2 );
(1)
template< class InputIt1, class InputIt2 >

bool includes( InputIt1 first1, InputIt1 last1,

               InputIt2 first2, InputIt2 last2, Compare comp );
(2)
Regreso true si cada elemento de la gama [first2, last2) ordenados se encuentra dentro de la gama [first, last) ordenados. También regresa true [first2, last2) si está vacío .
Original:
Returns true if every element from the sorted range [first2, last2) is found within the sorted range [first, last). Also returns true if [first2, last2) is empty.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
La primera versión espera que ambas gamas se ordenen con operator<, la segunda versión espera que se solucionó con la función de comparación dado comp .
Original:
The first version expects both ranges to be sorted with operator<, the second version expects them to be sorted with the given comparison function comp.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Contenido

[editar] Parámetros

first1, last1 -
la gama ordenada de elementos a examinar
Original:
the sorted range of elements to examine
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
first2, last2 -
la gama ordenada de elementos que desea buscar
Original:
the sorted range of elements to search for
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
comp - comparison function which returns ​true if the first argument is less than the second.

The signature of the comparison function should be equivalent to the following:

 bool cmp(const Type1 &a, const Type2 &b);

The signature does not need to have const &, but the function must not modify the objects passed to it.
The types Type1 and Type2 must be such that an object of type InputIt can be dereferenced and then implicitly converted to both of them. ​

Requerimientos de tipo
-
InputIt debe reunir los requerimientos de InputIterator.

[editar] Valor de retorno

true si cada elemento de [first2, last2) es un miembro de [first, last) .
Original:
true if every element from [first2, last2) is a member of [first, last).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Complejidad

En la mayoría de las comparaciones 2·(N1+N2-1), donde N1 = std::distance(first1, last1) y N2 = std::distance(first2, last2) .
Original:
At most 2·(N1+N2-1) comparisons, where N1 = std::distance(first1, last1) and N2 = std::distance(first2, last2).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[editar] Posible implementación

Primera versión
template<class InputIt1, class InputIt2>
bool includes(InputIt1 first1, InputIt1 last1,
              InputIt2 first2, InputIt2 last2)
{
    for (; first2 != last2; ++first1)
    {
        if (first1 == last1 || *first2 < *first1)
            return false;
        if ( !(*first1 < *first2) )
            ++first2;
    }
    return true;
}
Segunda versión
template<class InputIt1, class InputIt2>
bool includes(InputIt1 first1, InputIt1 last1,
              InputIt2 first2, InputIt2 last2, Compare comp)
{
    for (; first2 != last2; ++first1)
    {
        if (first1 == last1 || comp(*first2, *first1))
            return false;
        if (!comp(*first1, *first2))
            ++first2;
    }
    return true;
}

[editar] Ejemplo

#include <iostream>
#include <algorithm>
#include <cctype>
 
int main()
{
  std::vector<char> v1 {'a', 'b', 'c', 'f', 'h', 'x'};
  std::vector<char> v2 {'a', 'b', 'c'};
  std::vector<char> v3 {'a', 'c'};
  std::vector<char> v4 {'g'};
  std::vector<char> v5 {'a', 'c', 'g'};
  std::vector<char> v6;
 
  for (auto i : v1) std::cout << i << ' ';
  std::cout << "includes:\n";
 
  for (auto i : v2) std::cout << i << ' ';
  std::cout << ": " << std::includes(v1.begin(), v1.end(), v2.begin(), v2.end()) << '\n';
  for (auto i : v3) std::cout << i << ' ';
  std::cout << ": " << std::includes(v1.begin(), v1.end(), v3.begin(), v3.end()) << '\n';
  for (auto i : v4) std::cout << i << ' ';
  std::cout << ": " << std::includes(v1.begin(), v1.end(), v4.begin(), v4.end()) << '\n';
  for (auto i : v5) std::cout << i << ' ';
  std::cout << ": " << std::includes(v1.begin(), v1.end(), v5.begin(), v5.end()) << '\n';
  for (auto i : v6) std::cout << i << ' ';
  std::cout << ": " << std::includes(v1.begin(), v1.end(), v6.begin(), v6.end()) << '\n';
 
  auto cmp_nocase = [](char a, char b) {
    return std::tolower(a) < std::tolower(b);
  }
  std::vector<char> v7 {'A', 'B', 'C'};
  for (auto i : v7) std::cout << i << ' ';
  std::cout << ": "
            << std::includes(v1.begin(), v1.end(), v7.begin(), v7.end(), cmp_nocase)
            << '\n';
}

Salida:

a b c f h x includes:
a b c : 1
a c : 1
g : 0
a c g : 0
A B C : 1

[editar] Ver también

calcula la diferencia entre los dos conjuntos
Original:
computes the difference between two sets
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(plantilla de función) [editar]
busca a un rango de elementos
(plantilla de función) [editar]