std::ranges::copy_backward, std::ranges::copy_backward_result
Von de.cppreference.net
| Definiert in Header <algorithm>
|
||
| Aufrufsignatur |
||
template< std::bidirectional_iterator I1, std::sentinel_for<I1> S1,
std::bidirectional_iterator I2 >
requires std::indirectly_copyable<I1, I2>
constexpr copy_backward_result<I1, I2>
copy_backward( I1 first, S1 last, I2 d_last );
|
(1) | (seit C++20) |
template< ranges::bidirectional_range R, std::bidirectional_iterator I >
requires std::indirectly_copyable<ranges::iterator_t<R>, I>
constexpr copy_backward_result<ranges::borrowed_iterator_t<R>, I>
copy_backward( R&& r, I d_last );
|
(2) | (seit C++20) |
| Hilfstypen |
||
template< class I1, class I2 >
using copy_backward_result = ranges::in_out_result<I1, I2>;
|
(3) | (seit C++20) |
1) Kopiert die Elemente aus dem Bereich, definiert durch
[first, last), in einen anderen Bereich [d_last - N, d_last), wobei N = ranges::distance(first, last). Die Elemente werden in umgekehrter Reihenfolge kopiert (das letzte Element zuerst), aber ihre relative Reihenfolge bleibt erhalten. Das Verhalten ist undefiniert, wenn d_last innerhalb von (first, last] liegt. In einem solchen Fall kann std::ranges::copy stattdessen verwendet werden.2) Gleich wie (1), verwendet aber
r als Quellbereich, als ob ranges::begin(r) als first und ranges::end(r) als last verwendet würden.Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell bekannt als Niebloids), das heißt:
- Explizite Vorlagenargumentlisten können beim Aufruf einer von ihnen nicht angegeben werden.
- Keine von ihnen sind für argumentabhängige Suche sichtbar.
- Wenn eine von ihnen durch normale unqualifizierte Suche als Name links vom Funktionsaufrufoperator gefunden wird, wird die argumentabhängige Suche unterdrückt.
Parameter
| first, last | - | das Iterator-Sentinel-Paar, das den Bereich der zu kopierenden Elemente definiert |
| r | - | der Bereich der zu kopierenden Elemente |
| d_last | - | das Ende des Zielbereichs |
Rückgabewert
{last, d_last - N}
Komplexität
Genau N Zuweisungen.
Hinweise
Beim Kopieren überlappender Bereiche ist ranges::copy geeignet, wenn nach links kopiert wird (Anfang des Zielbereichs liegt außerhalb des Quellbereichs), während ranges::copy_backward geeignet ist, wenn nach rechts kopiert wird (Ende des Zielbereichs liegt außerhalb des Quellbereichs).
Mögliche Implementierung
struct copy_backward_fn
{
template<std::bidirectional_iterator I1, std::sentinel_for<I1> S1,
std::bidirectional_iterator I2>
requires std::indirectly_copyable<I1, I2>
constexpr ranges::copy_backward_result<I1, I2>
operator()(I1 first, S1 last, I2 d_last) const
{
I1 last1 {ranges::next(first, std::move(last))};
for (I1 i {last1}; i != first;)
*--d_last = *--i;
return {std::move(last1), std::move(d_last)};
}
template<ranges::bidirectional_range R, std::bidirectional_iterator I>
requires std::indirectly_copyable<ranges::iterator_t<R>, I>
constexpr ranges::copy_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 copy_backward_fn copy_backward{};
|
Beispiel
Diesen Code ausführen
#include <algorithm>
#include <iostream>
#include <ranges>
#include <string_view>
#include <vector>
void print(std::string_view rem, std::ranges::forward_range auto const& r)
{
for (std::cout << rem << ": "; auto const& elem : r)
std::cout << elem << ' ';
std::cout << '\n';
}
int main()
{
const auto src = {1, 2, 3, 4};
print("src", src);
std::vector<int> dst(src.size() + 2);
std::ranges::copy_backward(src, dst.end());
print("dst", dst);
std::ranges::fill(dst, 0);
const auto [in, out] =
std::ranges::copy_backward(src.begin(), src.end() - 2, dst.end());
print("dst", dst);
std::cout
<< "(in - src.begin) == " << std::distance(src.begin(), in) << '\n'
<< "(out - dst.begin) == " << std::distance(dst.begin(), out) << '\n';
}
Ausgabe:
src: 1 2 3 4
dst: 0 0 1 2 3 4
dst: 0 0 0 0 1 2
(in - src.begin) == 2
(out - dst.begin) == 4
Siehe auch
(C++20)(C++20) |
kopiert einen Bereich von Elementen an einen neuen Speicherort (Algorithmus-Funktionsobjekt) |
(C++20) |
kopiert eine bestimmte Anzahl von Elementen an einen neuen Speicherort (Algorithmus-Funktionsobjekt) |
(C++20)(C++20) |
kopiert einen Bereich von Elementen und lässt diejenigen aus, die bestimmte Kriterien erfüllen (Algorithmus-Funktionsobjekt) |
(C++20)(C++20) |
kopiert einen Bereich und ersetzt Elemente, die bestimmte Kriterien erfüllen, durch einen anderen Wert (Algorithmus-Funktionsobjekt) |
(C++20) |
erstellt eine umgekehrte Kopie eines Bereichs (Algorithmus-Funktionsobjekt) |
(C++20) |
kopiert und rotiert einen Bereich von Elementen (Algorithmus-Funktionsobjekt) |
(C++20) |
erstellt eine Kopie eines Bereichs von Elementen, die keine aufeinanderfolgenden Duplikate enthält (Algorithmus-Funktionsobjekt) |
(C++20) |
verschiebt einen Bereich von Elementen an einen neuen Speicherort (Algorithmus-Funktionsobjekt) |
(C++20) |
verschiebt einen Bereich von Elementen in umgekehrter Reihenfolge an einen neuen Speicherort (Algorithmus-Funktionsobjekt) |
| kopiert einen Bereich von Elementen in umgekehrter Reihenfolge (Funktionstemplate) |