std::ranges::move_backward, std::ranges::move_backward_result
Von cppreference.com
| Definiert in Header <algorithm> |
||
| Aufruf-Signatur |
||
| template< std::bidirectional_iterator I1, std::sentinel_for<I1> S1, std::bidirectional_iterator I2 > |
(1) | (seit C++20) |
| template< ranges::bidirectional_range R, std::bidirectional_iterator I > requires std::indirectly_movable<ranges::iterator_t<R>, I> |
(2) | (seit C++20) |
| Hilfstypen |
||
| template< class I, class O > using move_backward_result = ranges::in_out_result<I, O>; |
(3) | (seit C++20) |
1) Verschiebt die Elemente im Bereich, der durch
[first, last) definiert ist, in einen anderen Bereich [d_last - N, d_last), wobei N = ranges::distance(first, last). Die Elemente werden in umgekehrter Reihenfolge verschoben (das letzte Element wird zuerst verschoben), aber ihre relative Reihenfolge bleibt erhalten. Das Verhalten ist undefiniert, wenn d_last innerhalb von (first, last] liegt. In diesem Fall kann stattdessen ranges::move verwendet werden.2) Entspricht (1), verwendet jedoch r als Quellbereich, als ob ranges::begin(r) als first und ranges::end(r) als last verwendet würden.
Die Elemente im *verschobenen* Bereich enthalten immer noch gültige Werte des entsprechenden Typs, aber nicht notwendigerweise dieselben Werte wie vor dem Verschieben, als ob für jede ganze Zahl n, wobei 0 ≤ n < N, *(d_last - n) = ranges::iter_move(last - n) verwendet würde.
Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell als niebloids bekannt), d.h.
- Können explizite Template-Argumentlisten bei keinem von ihnen angegeben werden.
- Keiner von ihnen ist für Argument-abhängige Suche sichtbar.
- Wenn einer von ihnen durch normale unqualifizierte Suche als Name links vom Funktionsaufrufoperator gefunden wird, wird die Argument-abhängige Suche unterdrückt.
Inhalt |
[bearbeiten] Parameter
| first, last | - | das Iterator-Sentinel-Paar, das den Bereich der zu verschiebenden Elemente definiert |
| r | - | der Bereich der zu verschiebenden Elemente |
| d_last | - | Das Ende des Zielbereichs |
[bearbeiten] Rückgabewert
{last, d_last - N}.
[bearbeiten] Komplexität
1) Genau N Zuweisungen durch Verschieben.
2) Genau ranges::distance(r) Zuweisungen durch Verschieben.
[bearbeiten] Hinweise
Beim Verschieben überlappender Bereiche ist ranges::move für das Verschieben nach links (der Anfang des Zielbereichs liegt außerhalb des Quellbereichs) geeignet, während ranges::move_backward für das Verschieben nach rechts (das Ende des Zielbereichs liegt außerhalb des Quellbereichs) geeignet ist.
[bearbeiten] Mögliche Implementierung
struct move_backward_fn { template<std::bidirectional_iterator I1, std::sentinel_for<I1> S1, std::bidirectional_iterator I2> requires std::indirectly_movable<I1, I2> constexpr ranges::move_backward_result<I1, I2> operator()(I1 first, S1 last, I2 d_last) const { auto i {last}; for (; i != first; *--d_last = ranges::iter_move(--i)) {} return {std::move(last), std::move(d_last)}; } template<ranges::bidirectional_range R, std::bidirectional_iterator I> requires std::indirectly_movable<ranges::iterator_t<R>, I> constexpr ranges::move_backward_result<ranges::borrowed_iterator_t<R>, I> operator()(R&& r, I d_last) const { return (*this)(ranges::begin(r), ranges::end(r), std::move(d_last)); } }; inline constexpr move_backward_fn move_backward {}; |
[bearbeiten] Beispiel
Führen Sie diesen Code aus
#include <algorithm> #include <iostream> #include <string> #include <string_view> #include <vector> using Vec = std::vector<std::string>; void print(std::string_view rem, Vec const& vec) { std::cout << rem << "[" << vec.size() << "]: "; for (const std::string& s : vec) std::cout << (s.size() ? s : std::string{"·"}) << ' '; std::cout << '\n'; } int main() { Vec a{"▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"}; Vec b(a.size()); print("Before move:\n" "a", a); print("b", b); std::ranges::move_backward(a, b.end()); print("\n" "Move a >> b:\n" "a", a); print("b", b); std::ranges::move_backward(b.begin(), b.end(), a.end()); print("\n" "Move b >> a:\n" "a", a); print("b", b); std::ranges::move_backward(a.begin(), a.begin()+3, a.end()); print("\n" "Overlapping move a[0, 3) >> a[5, 8):\n" "a", a); }
Mögliche Ausgabe
Before move: a[8]: ▁ ▂ ▃ ▄ ▅ ▆ ▇ █ b[8]: · · · · · · · · Move a >> b: a[8]: · · · · · · · · b[8]: ▁ ▂ ▃ ▄ ▅ ▆ ▇ █ Move b >> a: a[8]: ▁ ▂ ▃ ▄ ▅ ▆ ▇ █ b[8]: · · · · · · · · Overlapping move a[0, 3) >> a[5, 8): a[8]: · · · ▄ ▅ ▁ ▂ ▃
[bearbeiten] Siehe auch
| (C++20) |
Verschiebt einen Elementbereich an einen neuen Speicherort (Algorithmus-Funktionsobjekt) |
| (C++20)(C++20) |
Kopiert einen Elementbereich an einen neuen Speicherort (Algorithmus-Funktionsobjekt) |
| (C++20) |
Kopiert einen Elementbereich in umgekehrter Reihenfolge (Algorithmus-Funktionsobjekt) |
| (C++11) |
Verschiebt einen Elementbereich an einen neuen Speicherort (Funktionstempelat) |
| (C++11) |
konvertiert das Argument in ein xvalue (Funktionsvorlage) |
