std::includes

Definido en el encabezado `<algorithm>`
template< class InputIt1, class InputIt2 > bool includes( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2 );	(1)	(constexpr desde C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > bool includes( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2 );	(2)	(desde C++17)
template< class InputIt1, class InputIt2, class Compare > bool includes( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, Compare comp );	(3)	(constexpr desde C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class Compare > bool includes( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2, Compare comp );	(4)	(desde C++17)

Devuelve true si el rango ordenado [first2, last2) es una subsecuencia del rango ordenado [first1, last1) (una subsecuencia no necesita ser contigua).

1) Si [first1, last1) o [first2, last2) no está ordenado con respecto a operator<(hasta C++20)std::less{}(desde C++20), el comportamiento no está definido.

3) Si [first1, last1) o [first2, last2) no está ordenado con respecto a comp, el comportamiento no está definido.

2,4) Igual que (1,3), pero ejecutado de acuerdo con policy.

Estas sobrecargas participan en la resolución de sobrecarga solo si el valor de la siguiente expresión es true:

`std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>`	(hasta C++20)
`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>`	(desde C++20)

Parámetros

first1, last1	-	el par de iteradores que definen el rango ordenado de elementos a examinar
first2, last2	-	el par de iteradores que definen el rango ordenado de elementos a buscar
policy	-	la política de ejecución a usar
comp	-	objeto función de comparación (es decir, un objeto que satisface los requisitos de Compare) que devuelve `true` si el primer argumento es menor que (es decir, está ordenado antes) que el segundo. La signatura de la función de comparación debe ser equivalente a la siguiente: `bool cmp(const Type1& a, const Type2& b);` Aunque la signatura no necesita tener `const&`, la función no debe modificar los objetos que se le pasan y debe ser capaz de aceptar todos los valores de tipo (posiblemente const) `Type1` y `Type2` independientemente de la categoría de valor (por lo tanto, `Type1&` no está permitido, ni `Type1` a menos que para `Type1` un movimiento sea equivalente a una copia(desde C++11)). Los tipos `Type1` y `Type2` deben ser tales que un objeto de tipo `InputIt` pueda ser desreferenciado y luego convertido implícitamente a ambos.
Requisitos de tipo
- `InputIt1, InputIt2` debe cumplir los requisitos de LegacyInputIterator.
- `ForwardIt1, ForwardIt2` debe cumplir los requisitos de LegacyForwardIterator.
- `Compare` debe cumplir los requisitos de Compare.

Valor de retorno

true si [first2, last2) es una subsecuencia de [first1, last1); en caso contrario false.

Una secuencia vacía es una subsecuencia de cualquier secuencia, por lo que se devuelve true si [first2, last2) está vacío.

Complejidad

Dado $\scriptsize N_1$ $N 1$ como std::distance(first1, last1) y $\scriptsize N_2$ $N 2$ como std::distance(first2, last2):

1,2) Como máximo

2\cdot(N 1 +N 2)-1

comparaciones usando operator<(hasta C++20)std::less{}(desde C++20).

3,4) Como máximo

2\cdot(N 1 +N 2)-1

aplicaciones de la función de comparación comp.

Excepciones

Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy informan errores de la siguiente manera:

Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y ExecutionPolicy es una de las políticas estándar, se llama a std::terminate. Para cualquier otra ExecutionPolicy, el comportamiento está definido por la implementación.
Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.

Posible implementación

incluir (1)

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

incluir (3)

template<class InputIt1, class InputIt2, class Compare>
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;
}

Ejemplo

Ejecutar este código

#include <algorithm>
#include <cctype>
#include <iostream>

template<class Os, class Co>
Os& operator<<(Os& os, const Co& v)
{
    for (const auto& i : v)
        os << i << ' ';
    return os << '\t';
}

int main()
{
    const auto
        v1 = {'a', 'b', 'c', 'f', 'h', 'x'},
        v2 = {'a', 'b', 'c'},
        v3 = {'a', 'c'},
        v4 = {'a', 'a', 'b'},
        v5 = {'g'},
        v6 = {'a', 'c', 'g'},
        v7 = {'A', 'B', 'C'};

    auto no_case = [](char a, char b) { return std::tolower(a) < std::tolower(b); };

    std::cout
    << v1 << "\nincludes:\n" << std::boolalpha
    << v2 << ": " << std::includes(v1.begin(), v1.end(), v2.begin(), v2.end()) << '\n'
    << v3 << ": " << std::includes(v1.begin(), v1.end(), v3.begin(), v3.end()) << '\n'
    << v4 << ": " << std::includes(v1.begin(), v1.end(), v4.begin(), v4.end()) << '\n'
    << v5 << ": " << std::includes(v1.begin(), v1.end(), v5.begin(), v5.end()) << '\n'
    << v6 << ": " << std::includes(v1.begin(), v1.end(), v6.begin(), v6.end()) << '\n'
    << v7 << ": " << std::includes(v1.begin(), v1.end(), v7.begin(), v7.end(), no_case)
          << " (case-insensitive)\n";
}

Salida:

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 (case-insensitive)

Informes de defectos

Los siguientes informes de defectos que cambian el comportamiento se aplicaron retroactivamente a los estándares C++ previamente publicados.

DR	Aplicado a	Comportamiento como publicado	Comportamiento correcto
LWG 1205	C++98	el valor de retorno no estaba claro si `[first2,` `last2)` está vacío	devuelve `true` en este caso

Véase también

set_difference	calcula la diferencia entre dos conjuntos (plantilla de función & objeto función de algoritmo)
ranges::set_difference (C++20)
search	busca la primera aparición de un rango de elementos (plantilla de función & objeto función de algoritmo)
ranges::search (C++20)
ranges::includes (C++20)	determina si una secuencia es una subsecuencia de otra (objeto función de algoritmo)

Soporte del compilador
Independiente y alojado
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos nombrados
Macros de prueba de características (C++20)
Biblioteca de soporte del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de utilidades generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca de numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca de sistema de archivos (C++17)
Biblioteca de soporte de concurrencia (C++11)
Biblioteca de control de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

es.cppreference.net

Namespaces

Variants