Namensräume
Varianten
Aktionen

std::uninitialized_copy

Von cppreference.com
< cpp‎ | memory
 
C++
 
Speicherverwaltungsbibliothek
(nur Exposition*)
Algorithmen für uninitialisierten Speicher
uninitialized_copy
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++11)
(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 InputIt, class NoThrowForwardIt >

NoThrowForwardIt uninitialized_copy( InputIt first, InputIt last,

                                     NoThrowForwardIt d_first );
 (1) (constexpr seit C++26)
template< class ExecutionPolicy, class ForwardIt,

          class NoThrowForwardIt >
NoThrowForwardIt uninitialized_copy( ExecutionPolicy&& policy,
                                     ForwardIt first, ForwardIt last,

                                     NoThrowForwardIt d_first );
 (2) (seit C++17)
1) Kopiert Elemente aus dem Bereich [first, last) in einen nicht initialisierten Speicherbereich, der bei d_first beginnt, so als ob durch

for (; first != last; ++d_first, (void) ++first)
    ::new (voidify(*d_first))
        typename std::iterator_traits<NoThrowForwardIt>::value_type(*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)


Wenn d_first + [​0​, std::distance(first, last)) mit [first, last) überlappt, ist das Verhalten undefiniert.

 (seit C++20)

Inhalt

[bearbeiten] Parameter

first, last - das Iterator-Paar, das den Bereich der zu kopierenden Elemente definiert
d_first - der Anfang des Zielbereichs
policy - die Ausführungsrichtlinie, die verwendet werden soll
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.
-
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

Iterator auf das Element nach dem letzten kopierten Element.

[bearbeiten] Komplexität

Linear zur Distanz zwischen first und last.

[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 InputIt, class NoThrowForwardIt>
constexpr NoThrowForwardIt uninitialized_copy(InputIt first, InputIt last,
                                              NoThrowForwardIt d_first)
{
    using T = typename std::iterator_traits<NoThrowForwardIt>::value_type;
    NoThrowForwardIt current = d_first;
    try
    {
        for (; first != last; ++first, (void) ++current)
            ::new (static_cast<void*>(std::addressof(*current))) T(*first);
        return current;
    }
    catch (...)
    {
        for (; d_first != current; ++d_first)
            d_first->~T();
        throw;
    }
}

[bearbeiten] Beispiel

Führen Sie diesen Code aus
#include <cstdlib>
#include <iostream>
#include <memory>
#include <string>
 
int main()
{
    const char *v[] = {"This", "is", "an", "example"};
 
    auto sz = std::size(v);
 
    if (void *pbuf = std::aligned_alloc(alignof(std::string), sizeof(std::string) * sz))
    {
        try
        {
            auto first = static_cast<std::string*>(pbuf);
            auto last = std::uninitialized_copy(std::begin(v), std::end(v), first);
 
            for (auto it = first; it != last; ++it)
                std::cout << *it << '_';
            std::cout << '\n';
 
            std::destroy(first, last);
        }
        catch (...) {}
        std::free(pbuf);
    }
}

Ausgabe

This_is_an_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 globale Ersatz-
new stattdessen
LWG 2133 C++98 Die Effektdarstellung verwendete eine for-Schleife mit dem Iterationsausdruck
++d_first, ++first, was zu
einem argumentabhängigen Lookup von operator,		 verwirft den Wert
eines Operanden
führt, um diesen ADL
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

(C++11)
 kopiert eine Anzahl von Objekten in einen uninitialisierten Speicherbereich
(Funktions-Template) [edit]
(C++20)
 kopiert einen Bereich von Objekten in einen uninitialisierten Speicherbereich
(Algorithmus-Funktionsobjekt)[edit]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/memory/uninitialized_copy&oldid=180308"
English Deutsch 日本語 中文(简体) 中文(繁體)