std::ranges:: contains, std::ranges:: contains_subrange
|
Défini dans l'en-tête
<algorithm>
|
||
|
Signature d'appel
|
||
| (1) | ||
|
template
<
std::
input_iterator
I,
std::
sentinel_for
<
I
>
S,
class
T,
|
(depuis C++23)
(jusqu'à C++26) |
|
|
template
<
std::
input_iterator
I,
std::
sentinel_for
<
I
>
S,
class
Proj
=
std::
identity
,
|
(depuis C++26) | |
| (2) | ||
|
template
<
ranges::
input_range
R,
class
T,
|
(depuis C++23)
(jusqu'à C++26) |
|
|
template
<
ranges::
input_range
R,
class
Proj
=
std::
identity
,
|
(depuis C++26) | |
|
template
<
std::
forward_iterator
I1,
std::
sentinel_for
<
I1
>
S1,
std::
forward_iterator
I2,
std::
sentinel_for
<
I2
>
S2,
|
(3) | (depuis C++23) |
|
template
<
ranges::
forward_range
R1,
ranges::
forward_range
R2,
class
Pred
=
ranges::
equal_to
,
|
(4) | (depuis C++23) |
[
first
,
last
)
.
[
ranges::
begin
(
r
)
,
ranges::
end
(
r
)
)
.
[
first1
,
last1
)
, et la deuxième plage source est
[
first2
,
last2
)
.
[
ranges::
begin
(
r1
)
,
ranges::
end
(
r1
)
)
, et la deuxième plage source est
[
ranges::
begin
(
r2
)
,
ranges::
end
(
r2
)
)
.
Les entités de type fonction décrites sur cette page sont des objets fonction d'algorithme (informellement appelés niebloids ), c'est-à-dire :
- Les listes d'arguments de template explicites ne peuvent pas être spécifiées lors de l'appel de l'une d'entre elles.
- Aucune d'entre elles n'est visible pour la recherche dépendante des arguments .
- Lorsque l'une d'entre elles est trouvée par la recherche non qualifiée normale comme nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.
Table des matières |
Paramètres
| first, last | - | la paire itérateur-sentinelle définissant la plage des éléments à examiner |
| r | - | la plage des éléments à examiner |
| value | - | valeur à comparer aux éléments |
| pred | - | prédicat à appliquer aux éléments projetés |
| proj | - | projection à appliquer aux éléments |
Valeur de retour
! ranges:: search ( ranges:: begin ( r1 ) , ranges:: end ( r1 ) ,
ranges:: begin ( r2 ) , ranges:: end ( r2 ) , pred, proj1, proj2 ) . empty ( )
Complexité
Notes
En C++20, on peut implémenter une fonction contains avec ranges:: find ( haystack, needle ) ! = ranges:: end ( haystack ) ou une fonction contains_subrange avec ! ranges:: search ( haystack, needle ) . empty ( ) .
ranges::contains_subrange
, comme
ranges::search
, et contrairement à
std::search
, ne prend pas en charge les
searchers
(tels que
std::boyer_moore_searcher
).
| Macro de test de fonctionnalité | Valeur | Std | Fonctionnalité |
|---|---|---|---|
__cpp_lib_ranges_contains
|
202207L
|
(C++23) |
ranges::contains
et
ranges::contains_subrange
|
__cpp_lib_algorithm_default_value_type
|
202403L
|
(C++26) | Initialisation par liste pour les algorithmes ( 1,2 ) |
Implémentation possible
| contient (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{}; |
| contient_sous_plage (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{}; |
Exemple
#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 }
Voir aussi
|
(C++20)
(C++20)
(C++20)
|
trouve le premier élément satisfaisant des critères spécifiques
(objet fonction algorithme) |
|
(C++20)
|
recherche la première occurrence d'une plage d'éléments
(objet fonction algorithme) |
|
(C++20)
|
détermine si un élément existe dans une plage partiellement ordonnée
(objet fonction algorithme) |
|
(C++20)
|
retourne
true
si une séquence est une sous-séquence d'une autre
(objet fonction algorithme) |
|
(C++20)
(C++20)
(C++20)
|
vérifie si un prédicat est
true
pour tous, certains ou aucun des éléments d'une plage
(objet fonction algorithme) |