std::uninitialized_fill
Von de.cppreference.net
| Definiert in Header <memory>
|
||
template< class NoThrowForwardIt, class T >
void uninitialized_fill( NoThrowForwardIt first,
NoThrowForwardIt last, const T& value );
|
(1) | (constexpr seit C++26) |
template< class ExecutionPolicy, class NoThrowForwardIt, class T >
void uninitialized_fill( ExecutionPolicy&& policy,
NoThrowForwardIt first,
NoThrowForwardIt last, const T& value );
|
(2) | (seit C++17) |
1) Konstruiert Elemente im Zielbereich
[first, last) mit dem angegebenen Wert value wie durch
for (; first != last; ++first)
::new (voidify(*first))
typename std::iterator_traits<NoThrowForwardIt>::value_type(value);
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), aber 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) |
Parameter
| first, last | - | das Paar von Iteratoren, das den Bereich der zu initialisierenden Elemente definiert |
| value | - | der Wert, mit dem die Elemente konstruiert werden sollen |
| policy | - | die zu verwendende Ausführungsrichtlinie |
| Typanforderungen | ||
-
NoThrowForwardIt
muss die Anforderungen von
LegacyForwardIterator
erfüllen.
|
||
-
NoThrowForwardIt
dürfen Ausnahmen werfen.
Die Anwendung von
&
*
auf einen
NoThrowForwardIt
-Wert muss einen Zeiger auf seinen Werttyp ergeben.
(bis C++11)
|
||
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 ausgelöst.
- Falls eine nicht abgefangene Ausnahme beim Zugriff auf Objekte über ein Algorithmusargument ausgelöst wird, wird das Verhalten durch die Ausführungsrichtlinie bestimmt (für Standardrichtlinien, std::terminate wird aufgerufen).
Anmerkungen
| Feature-TestMakro | Wert | Std | Feature |
|---|---|---|---|
__cpp_lib_raw_memory_algorithms |
202411L |
(C++26) | constexpr für spezialisierte <memory>Algorithmen, (1)
|
Mögliche Implementierung
template<class NoThrowForwardIt, class T> constexpr void uninitialized_fill(NoThrowForwardIt first, NoThrowForwardIt last, const T& value) { using V = typename std::iterator_traits<NoThrowForwardIt>::value_type; NoThrowForwardIt current = first; try { for (; current != last; ++current) ::new (static_cast<void*>(std::addressof(*current))) V(value); } catch (...) { for (; first != current; ++first) first->~V(); throw; } } |
Beispiel
Diesen Code ausführen
#include <algorithm> #include <iostream> #include <memory> #include <string> int main() { const std::size_t sz = 4; std::allocator<std::string> alloc; std::string* p = alloc.allocate(sz); std::uninitialized_fill(p, p + sz, "Example"); for (std::string* i = p; i != p + sz; ++i) { std::cout << *i << '\n'; i->~basic_string<char>(); } alloc.deallocate(p, sz); }
Ausgabe:
Example Example Example Example
Fehlerberichte
Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.
| DR | Angewendet auf | Verhalten wie veröffentlicht | Richtiges Verhalten |
|---|---|---|---|
| LWG 866 | C++98 | gegeben T als Werttyp von NoThrowForwardIt, falls T::operator new existiert, könnte das Programm fehlerhaft sein
|
verwendet globales placement new stattdessen
|
| LWG 2433 | C++11 | dieser Algorithmus könnte durch überladene operator&
|
verwendet std::addressof |
Siehe auch
|
kopiert ein Objekt in einen nicht initialisierten Speicherbereich, definiert durch einen Startpunkt und eine Anzahl
(Funktions-Template) |
|
|
(C++20)
|
kopiert ein Objekt in einen nicht initialisierten Speicherbereich, definiert durch einen Bereich
(Algorithmus-Funktionsobjekt) |