Namensräume
Varianten
Aktionen

std::uninitialized_fill_n

Von cppreference.com
< cpp‎ | memory
 
C++
 
Speicherverwaltungsbibliothek
(nur Exposition*)
Algorithmen für uninitialisierten Speicher
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++11)
uninitialized_fill_n
(C++17)
(C++17)
(C++17)
(C++17)
(C++20)
Beschränkte uninitialisierte
Speicher-Algorithmen
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20) 
(C++20)
C-Bibliothek

Allocatoren
(C++11)
(C++23)
(C++11)
(C++11)
(C++20)
(C++20)
(C++20) 
(C++11)
(C++17)
Speicherressourcen
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
Unterstützung für Garbage Collection
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
Uninitialisierter Speicher
(bis C++20*)
(bis C++20*)
(bis C++20*)
Explizites Lebenszeitmanagement
(C++23)(C++23)
 
Definiert in Header <memory>
template< class NoThrowForwardIt, class Size, class T >
NoThrowForwardIt uninitialized_fill_n( NoThrowForwardIt first,

                                       Size count, const T& value );
 (1) (constexpr seit C++26)
template< class ExecutionPolicy,

          class NoThrowForwardIt, class Size, class T >
NoThrowForwardIt uninitialized_fill_n( ExecutionPolicy&& policy,
                                       NoThrowForwardIt first,

                                       Size count, const T& value );
 (2) (seit C++17)
1) Kopiert value in einen uninitialisierten Speicherbereich first + [​0​, count) als ob durch

for (; count--; ++first)
    ::new (voidify(*first))
        typename std::iterator_traits<NoThrowForwardIt>::value_type(value);
return first;

Wenn während der Initialisierung eine Ausnahme ausgelöst wird, werden die bereits konstruierten Objekte in nicht spezifizierter Reihenfolge zerstört.
2) Wie (1), wird aber gemäß policy ausgeführt.
Diese Überladung nimmt an der Überladungsauflösung teil, nur wenn alle folgenden Bedingungen erfüllt sind

std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> ist true.

 (bis C++20)

std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> ist true.

 (seit C++20)

Inhalt

[bearbeiten] Parameter

first - der Anfang des Bereichs der zu initialisierenden Elemente
zählt - Anzahl der zu konstruierenden Elemente
value - Der Wert, mit dem die Elemente konstruiert werden sollen
Typanforderungen
-
NoThrowForwardIt muss die Anforderungen von LegacyForwardIterator erfüllen.
-
Kein Inkrementieren, Zuweisen, Vergleichen oder Dereferenzieren von gültigen Instanzen von NoThrowForwardIt darf Ausnahmen auslösen. Das Anwenden von &* auf einen NoThrowForwardIt-Wert muss einen Zeiger auf seinen Werttyp ergeben.(bis C++11)

[bearbeiten] Rückgabewert

Wie oben beschrieben.

[bearbeiten] Komplexität

Linear in count.

[bearbeiten] Ausnahmen

Die Überladung mit einem Template-Parameter namens ExecutionPolicy meldet Fehler wie folgt

  • Wenn die Ausführung einer Funktion, die als Teil des Algorithmus aufgerufen wird, eine Ausnahme auslöst und ExecutionPolicy eine der Standardrichtlinien ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsabhängig.
  • Wenn dem Algorithmus der Speicher zur Neuzuweisung fehlt, wird std::bad_alloc ausgelöst.

[bearbeiten] Hinweise

Feature-Test-Makro Wert Std Feature
__cpp_lib_raw_memory_algorithms 202411L (C++26) constexpr für spezialisierte Speicher-Algorithmen, (1)

[bearbeiten] Mögliche Implementierung

template<class NoThrowForwardIt, class Size, class T>
constexpr NoThrowForwardIt uninitialized_fill_n(NoThrowForwardIt first,
                                                Size count, const T& value)
{
    using V = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = first;
    try
    {
        for (; count > 0; ++current, (void) --count)
            ::new (static_cast<void*>(std::addressof(*current))) V(value);
        return current;
    }
    catch (...)
    {
        for (; first != current; ++first)
            first->~V();
        throw;
    }
    return current;
}

[bearbeiten] Beispiel

Führen Sie diesen Code aus
#include <algorithm>
#include <iostream>
#include <memory>
#include <string>
#include <tuple>
 
int main()
{
    std::string* p;
    std::size_t sz;
    std::tie(p, sz) = std::get_temporary_buffer<std::string>(4);
    std::uninitialized_fill_n(p, sz, "Example");
 
    for (std::string* i = p; i != p + sz; ++i)
    {
        std::cout << *i << '\n';
        i->~basic_string<char>();
    }
    std::return_temporary_buffer(p);
}

Ausgabe

Example
Example
Example
Example

[bearbeiten] Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 866 C++98 wenn T der Werttyp von NoThrowForwardIt ist, und wenn
T::operator new existiert, kann das Programm ill-formed sein		 verwendet stattdessen globalen Placement new
LWG 1339 C++98 die Position des ersten Elements nach
der Füllbereich wurde nicht zurückgegeben		 zurückgegeben
LWG 2433 C++11 dieser Algorithmus kann durch überladenes operator& gekapert werden verwendet std::addressof
LWG 3870 C++20 dieser Algorithmus kann Objekte auf einem const Speicher erstellen nicht erlaubt

[bearbeiten] Siehe auch

 kopiert ein Objekt in einen uninitialisierten Speicherbereich, definiert durch einen Bereich
(Funktions-Template) [edit]
(C++20)
 kopiert ein Objekt in einen uninitialisierten Speicherbereich, definiert durch einen Start und eine Anzahl
(Algorithmus-Funktionsobjekt)[edit]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/memory/uninitialized_fill_n&oldid=179707"