std::ranges:: contains, std::ranges:: contains_subrange
|
Definido en el encabezado
<algorithm>
|
||
|
Firma de llamada
|
||
| (1) | ||
|
template
<
std::
input_iterator
I,
std::
sentinel_for
<
I
>
S,
class
T,
|
(desde C++23)
(hasta C++26) |
|
|
template
<
std::
input_iterator
I,
std::
sentinel_for
<
I
>
S,
class
Proj
=
std::
identity
,
|
(desde C++26) | |
| (2) | ||
|
template
<
ranges::
input_range
R,
class
T,
|
(desde C++23)
(hasta C++26) |
|
|
template
<
ranges::
input_range
R,
class
Proj
=
std::
identity
,
|
(desde C++26) | |
|
template
<
std::
forward_iterator
I1,
std::
sentinel_for
<
I1
>
S1,
std::
forward_iterator
I2,
std::
sentinel_for
<
I2
>
S2,
|
(3) | (desde C++23) |
|
template
<
ranges::
forward_range
R1,
ranges::
forward_range
R2,
class
Pred
=
ranges::
equal_to
,
|
(4) | (desde C++23) |
[
first
,
last
)
.
[
ranges::
begin
(
r
)
,
ranges::
end
(
r
)
)
.
[
first1
,
last1
)
, y el segundo rango de origen es
[
first2
,
last2
)
.
[
ranges::
begin
(
r1
)
,
ranges::
end
(
r1
)
)
, y el segundo rango de origen es
[
ranges::
begin
(
r2
)
,
ranges::
end
(
r2
)
)
.
Las entidades similares a funciones descritas en esta página son algorithm function objects (conocidas informalmente como niebloids ), es decir:
- No se pueden especificar listas de argumentos de plantilla explícitas al llamar a cualquiera de ellos.
- Ninguno de ellos es visible para la búsqueda dependiente de argumento .
- Cuando cualquiera de ellos es encontrado mediante la búsqueda no calificada normal como el nombre a la izquierda del operador de llamada de función, la búsqueda dependiente de argumento queda inhibida.
Contenidos |
Parámetros
| first, last | - | el par iterador-centinela que define el rango de elementos a examinar |
| r | - | el rango de los elementos a examinar |
| value | - | valor contra el cual comparar los elementos |
| pred | - | predicado a aplicar a los elementos proyectados |
| proj | - | proyección a aplicar a los elementos |
Valor de retorno
! ranges:: search ( ranges:: begin ( r1 ) , ranges:: end ( r1 ) ,
ranges:: begin ( r2 ) , ranges:: end ( r2 ) , pred, proj1, proj2 ) . empty ( )
Complejidad
Notas
En C++20, uno puede implementar una función contains con ranges:: find ( haystack, needle ) ! = ranges:: end ( haystack ) o contains_subrange con ! ranges:: search ( haystack, needle ) . empty ( ) .
ranges::contains_subrange
, al igual que
ranges::search
, y a diferencia de
std::search
, no tiene soporte para
searchers
(como
std::boyer_moore_searcher
).
| Macro de prueba de características | Valor | Estándar | Característica |
|---|---|---|---|
__cpp_lib_ranges_contains
|
202207L
|
(C++23) |
ranges::contains
y
ranges::contains_subrange
|
__cpp_lib_algorithm_default_value_type
|
202403L
|
(C++26) | Inicialización de lista para algoritmos ( 1,2 ) |
Implementación posible
| contiene (1,2) |
|---|
struct __contains_fn { template<std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity, class T = std::projected_value_t<I, Proj>> requires std::indirect_binary_predicate<ranges::equal_to, std::projected<I, Proj>, const T*> constexpr bool operator()(I first, S last, const T& value, Proj proj = {}) const { return ranges::find(std::move(first), last, value, proj) != last; } template<ranges::input_range R, class Proj = std::identity, class T = std::projected_value_t<ranges::iterator_t<R>, Proj>> requires std::indirect_binary_predicate<ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*> constexpr bool operator()(R&& r, const T& value, Proj proj = {}) const { return ranges::find(std::move(ranges::begin(r)), ranges::end(r), value, proj) != ranges::end(r); } }; inline constexpr __contains_fn contains{}; |
| contains_subrange (3,4) |
struct __contains_subrange_fn { template<std::forward_iterator I1, std::sentinel_for<I1> S1, std::forward_iterator I2, std::sentinel_for<I2> S2, class Pred = ranges::equal_to, class Proj1 = std::identity, class Proj2 = std::identity> requires std::indirectly_comparable<I1, I2, Pred, Proj1, Proj2> constexpr bool operator()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const { return (first2 == last2) || !ranges::search(first1, last1, first2, last2, pred, proj1, proj2).empty(); } template<ranges::forward_range R1, ranges::forward_range R2, class Pred = ranges::equal_to, class Proj1 = std::identity, class Proj2 = std::identity> requires std::indirectly_comparable<ranges::iterator_t<R1>, ranges::iterator_t<R2>, Pred, Proj1, Proj2> constexpr bool operator()(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const { return (first2 == last2) || !ranges::search(ranges::begin(r1), ranges::end(r1), ranges::begin(r2), ranges::end(r2), pred, proj1, proj2).empty(); } }; inline constexpr __contains_subrange_fn contains_subrange{}; |
Ejemplo
#include <algorithm> #include <array> #include <complex> namespace ranges = std::ranges; int main() { constexpr auto haystack = std::array{3, 1, 4, 1, 5}; constexpr auto needle = std::array{1, 4, 1}; constexpr auto bodkin = std::array{2, 5, 2}; static_assert ( ranges::contains(haystack, 4) && !ranges::contains(haystack, 6) && ranges::contains_subrange(haystack, needle) && !ranges::contains_subrange(haystack, bodkin) ); constexpr std::array<std::complex<double>, 3> nums{{{1, 2}, {3, 4}, {5, 6}}}; #ifdef __cpp_lib_algorithm_default_value_type static_assert(ranges::contains(nums, {3, 4})); #else static_assert(ranges::contains(nums, std::complex<double>{3, 4})); #endif }
Véase también
|
(C++20)
(C++20)
(C++20)
|
encuentra el primer elemento que satisface criterios específicos
(objeto función de algoritmo) |
|
(C++20)
|
busca la primera ocurrencia de un rango de elementos
(objeto función de algoritmo) |
|
(C++20)
|
determina si un elemento existe en un rango parcialmente ordenado
(objeto función de algoritmo) |
|
(C++20)
|
retorna
true
si una secuencia es una subsecuencia de otra
(objeto función de algoritmo) |
|
(C++20)
(C++20)
(C++20)
|
verifica si un predicado es
true
para todos, alguno o ninguno de los elementos en un rango
(objeto función de algoritmo) |