std:: includes

From cppreference.net

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

first2

last2

no está ordenado con respecto a operator < (hasta C++20) std:: less { } (desde C++20) , el comportamiento es indefinido.

3) Si

first1

last1

first2

last2

no está ordenado con respecto a comp , el comportamiento es indefinido.

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

Estas sobrecargas participan en la resolución de sobrecarga solo si se satisfacen todas las siguientes condiciones:

std:: is_execution_policy_v < std:: decay_t < ExecutionPolicy >> es true .	(hasta C++20)
std:: is_execution_policy_v < std:: remove_cvref_t < ExecutionPolicy >> es true .	(desde C++20)

Contenidos

Parámetros

first1, last1	-	el par de iteradores que define el rango ordenado de elementos a examinar
first2, last2	-	el par de iteradores que define el rango ordenado de elementos a buscar
policy	-	la política de ejecución a utilizar
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 de) el segundo. La firma de la función de comparación debe ser equivalente a lo siguiente: bool cmp ( const Type1 & a, const Type2 & b ) ; Aunque la firma no necesita tener const & , la función no debe modificar los objetos pasados a ella y debe poder 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 tampoco `Type1` a menos que para `Type1` un movimiento sea equivalente a una copia (since 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` deben cumplir con los requisitos de LegacyInputIterator .
- `ForwardIt1, ForwardIt2` deben cumplir con los requisitos de LegacyForwardIterator .
- `Compare` debe cumplir con los requisitos de Compare .

Valor de retorno

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

Una secuencia vacía es una subsecuencia de cualquier secuencia, por lo que true se devuelve 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 reportan 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 uno de los standard policies , std::terminate es llamado. Para cualquier otro ExecutionPolicy , el comportamiento está definido por la implementación.
Si el algoritmo falla al asignar memoria, std::bad_alloc es lanzado.

Implementación posible

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 modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

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

Véase también

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

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants