std::ranges::starts_with
Von de.cppreference.net
| Definiert im Header <algorithm>
|
||
| Aufrufsignatur |
||
template< std::input_iterator I1, std::sentinel_for<I1> S1,
std::input_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
starts_with( I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
Proj1 proj1 = {}, Proj2 proj2 = {} );
|
(1) | (seit C++23) |
template< ranges::input_range R1, ranges::input_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
starts_with( R1&& r1, R2&& r2, Pred pred = {},
Proj1 proj1 = {}, Proj2 proj2 = {} );
|
(2) | (seit C++23) |
Überprüft, ob der zweite Bereich das Präfix des ersten Bereichs ist.
1) Es seien
N1 und N2 die Größen der Bereiche [first1, last1) bzw. [first2, last2). Wenn N1 < N2, wird false zurückgegeben. Andernfalls wird true nur dann zurückgegeben, wenn jedes Element im Bereich [first2, last2) gleich dem entsprechenden Element in [first1, first1 + N2) ist. Der Vergleich erfolgt durch Anwendung des binären Prädikats pred auf Elemente in zwei Bereichen, die durch proj1 bzw. proj2 projiziert werden.2) Wie (1), verwendet aber
r1 und r2 als Quellbereiche, als ob ranges::begin(r1) als first1, ranges:begin(r2) als first2, ranges::end(r1) als last1 und ranges::end(r2) als last2 verwendet würde.Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell als Niebloide bekannt), das heißt:
- Explizite Vorlagenargumentlisten können beim Aufruf einer von ihnen nicht angegeben werden.
- Keine von ihnen ist für argumentabhängige Suche sichtbar.
- Wenn eine von ihnen durch normale unqualifizierte Suche als Name links vom Funktionsaufrufoperator gefunden wird, wird argumentabhängige Suche unterdrückt.
Parameter
| first1, last1 | - | das Iterator-Sentinel-Paar, das den Bereich der zu untersuchenden Elemente definiert |
| r1 | - | der Bereich der zu untersuchenden Elemente |
| first2, last2 | - | das Iterator-Sentinel-Paar, das den Bereich der als Präfix zu verwendenden Elemente definiert |
| r2 | - | der Bereich der als Präfix zu verwendenden Elemente |
| pred | - | das binäre Prädikat, das die projizierten Elemente vergleicht |
| proj1 | - | die Projektion, die auf die Elemente des zu untersuchenden Bereichs anzuwenden ist |
| proj2 | - | die Projektion, die auf die Elemente des als Präfix zu verwendenden Bereichs anzuwenden ist |
Rückgabewert
true wenn der zweite Bereich mit dem Präfix des ersten Bereichs übereinstimmt, false andernfalls.
Komplexität
Linear: höchstens min ( N1, N2 ) Anwendungen des Prädikats und beider Projektionen.
Mögliche Implementierung
struct starts_with_fn { template<std::input_iterator I1, std::sentinel_for<I1> S1, std::input_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 ranges::mismatch(std::move(first1), last1, std::move(first2), last2, std::move(pred), std::move(proj1), std::move(proj2) ).in2 == last2; } template<ranges::input_range R1, ranges::input_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 (*this)(ranges::begin(r1), ranges::end(r1), ranges::begin(r2), ranges::end(r2), std::move(pred), std::move(proj1), std::move(proj2)); } }; inline constexpr starts_with_fn starts_with {}; |
Hinweise
| Feature-Test Makro | Wert | Std | Feature |
|---|---|---|---|
__cpp_lib_ranges_starts_ends_with
|
202106L
|
(C++23) |
std::ranges::starts_with
,
std::ranges::ends_with
|
Beispiel
Diesen Code ausführen
#include <algorithm> #include <iostream> #include <ranges> #include <string_view> int main() { using namespace std::literals; constexpr auto ascii_upper = [](char8_t c) { return u8'a' <= c && c <= u8'z' ? static_cast<char8_t>(c + u8'A' - u8'a') : c; }; constexpr auto cmp_ignore_case = [=](char8_t x, char8_t y) { return ascii_upper(x) == ascii_upper(y); }; static_assert(std::ranges::starts_with("const_cast", "const"sv)); static_assert(std::ranges::starts_with("constexpr", "const"sv)); static_assert(!std::ranges::starts_with("volatile", "const"sv)); std::cout << std::boolalpha << std::ranges::starts_with(u8"Constantinopolis", u8"constant"sv, {}, ascii_upper, ascii_upper) << ' ' << std::ranges::starts_with(u8"Istanbul", u8"constant"sv, {}, ascii_upper, ascii_upper) << ' ' << std::ranges::starts_with(u8"Metropolis", u8"metro"sv, cmp_ignore_case) << ' ' << std::ranges::starts_with(u8"Acropolis", u8"metro"sv, cmp_ignore_case) << '\n'; constexpr static auto v = { 1, 3, 5, 7, 9 }; constexpr auto odd = [](int x) { return x % 2; }; static_assert(std::ranges::starts_with(v, std::views::iota(1) | std::views::filter(odd) | std::views::take(3))); }
Ausgabe:
true false true false
Siehe auch
|
(C++23)
|
prüft, ob ein Bereich mit einem anderen Bereich endet
(Algorithmus-Funktionsobjekt) |
|
(C++20)
|
findet die erste Position, an der sich zwei Bereiche unterscheiden
(Algorithmus-Funktionsobjekt) |
|
(C++20)
|
prüft, ob der String mit dem gegebenen Präfix beginnt
(öffentliche Elementfunktion von
std::basic_string<CharT,Traits,Allocator>
)
|
|
(C++20)
|
prüft, ob die String-Ansicht mit dem gegebenen Präfix beginnt
(öffentliche Elementfunktion von
std::basic_string_view<CharT,Traits>
)
|