std::uninitialized_copy_n
Von de.cppreference.net
| Definiert in Header <memory>
|
||
template< class InputIt, class Size, class NoThrowForwardIt >
NoThrowForwardIt uninitialized_copy_n( InputIt first, Size count,
NoThrowForwardIt d_first );
|
(1) | (seit C++11) (constexpr seit C++26) |
template< class ExecutionPolicy, class ForwardIt,
class Size, class NoThrowForwardIt >
NoThrowForwardIt uninitialized_copy_n( ExecutionPolicy&& policy,
ForwardIt first, Size count,
NoThrowForwardIt d_first );
|
(2) | (seit C++17) |
1) Konstruiert Elemente im Zielbereich beginnend bei
d_first aus den ersten count Elementen im Quellbereich beginnend bei first wie durch
for (; count > 0; ++d_first, (void) ++first, --count)
::new (voidify(*d_first))
typename std::iterator_traits<NoThrowForwardIt>::value_type(*first);
return d_first;
Wenn während der Initialisierung eine Ausnahme ausgelöst wird, werden die bereits konstruierten Objekte in einer nicht spezifizierten Reihenfolge zerstört.
2) Gleiches wie (1), jedoch ausgeführt gemäß
policy. Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn der Wert des folgenden Ausdrucks
true ist:
|
|
(bis C++20) |
|
|
(seit C++20) |
|
Wenn |
(seit C++20) |
Parameter
| first | - | der Beginn des Bereichs der zu kopierenden Elemente |
| count | - | die Anzahl der zu kopierenden Elemente |
| d_first | - | der Beginn des Zielbereichs |
| policy | - | die Ausführungsrichtlinie zu verwenden |
| Typanforderungen | ||
-InputIt muss die Anforderungen von LegacyInputIterator erfüllen.
| ||
-ForwardIt muss die Anforderungen von LegacyForwardIterator erfüllen.
| ||
-NoThrowForwardIt muss die Anforderungen von LegacyForwardIterator erfüllen.
| ||
-Keine Inkrementierung, Zuweisung, Vergleich oder Dereferenzierung durch gültige Instanzen von NoThrowForwardIt darf Ausnahmen werfen.
| ||
Rückgabewert
Wie oben beschrieben.
Ausnahmen
2) Während des Ausführungsprozesses:
- Falls die temporären Speicherressourcen, die für die Parallelisierung erforderlich sind, nicht verfügbar sind, std::bad_alloc wird geworfen.
- Falls eine nicht abgefangene Ausnahme beim Zugriff auf Objekte über ein Algorithmusargument geworfen wird, wird das Verhalten durch die Ausführungsrichtlinie bestimmt (für Standardrichtlinien, std::terminate wird aufgerufen).
Anmerkungen
| Feature-Test Makro | Wert | Standard | Feature |
|---|---|---|---|
__cpp_lib_raw_memory_algorithms |
202411L |
(C++26) | constexpr für spezialisierte <memory> Algorithmen, (1)
|
Mögliche Implementierung
template<class InputIt, class Size, class NoThrowForwardIt> constexpr NoThrowForwardIt uninitialized_copy_n(InputIt first, Size count, NoThrowForwardIt d_first) { using T = typename std::iterator_traits<NoThrowForwardIt>::value_type; NoThrowForwardIt current = d_first; try { for (; count > 0; ++first, (void) ++current, --count) ::new (static_cast<void*>(std::addressof(*current))) T(*first); } catch (...) { for (; d_first != current; ++d_first) d_first->~T(); throw; } return current; } |
Beispiel
Diesen Code ausführen
#include <algorithm> #include <iostream> #include <memory> #include <string> #include <tuple> #include <vector> int main() { std::vector<std::string> v = {"This", "is", "an", "example"}; std::string* p; std::size_t sz; std::tie(p, sz) = std::get_temporary_buffer<std::string>(v.size()); sz = std::min(sz, v.size()); std::uninitialized_copy_n(v.begin(), sz, p); for (std::string* i = p; i != p + sz; ++i) { std::cout << *i << ' '; i->~basic_string<char>(); } std::cout << '\n'; std::return_temporary_buffer(p); }
Mögliche Ausgabe:
This is an example
Fehlerberichte
Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.
| DR | Angewendet auf | Verhalten wie veröffentlicht | Korrektes Verhalten |
|---|---|---|---|
| LWG 2133 | C++98 | die Wirkungsbeschreibung verwendete eine for Schleife mit dem Iterationsausdruck ++d_first, ++first, --count, welcherführt zu argumentabhängigen Suchen von operator,
|
verwirft den Wert eines Operanden um diese ADLs zu deaktivieren |
| LWG 2433 | C++11 | dieser Algorithmus könnte durch überladene operator&
|
verwendet std::addressof |
Siehe auch
|
kopiert eine Reihe von Objekten in einen nicht initialisierten Speicherbereich
(Funktions-Template) |
|
|
(C++20)
|
kopiert eine Anzahl von Objekten in einen nicht initialisierten Speicherbereich
(Algorithmus-Funktionsobjekt) |