concurrent_vector-Klasse

Die concurrent_vector-Klasse ist eine Sequenzcontainerklasse, die zufälligen Zugriff auf jedes Element zulässt. Sie aktiviert parallelitätssichere Operationen für Anfügen, Elementzugriff, Iteratorzugriff und Iteratordurchlauf. Hier sind Parallelitätssichere Zeiger oder Iteratoren immer gültig. Es gibt weder eine Garantie für die Initialisierung von Elementen noch für eine bestimmte Traversierungsreihenfolge.

Syntax

template<typename T, class _Ax>
class concurrent_vector: protected details::_Allocator_base<T,
    _Ax>,
private details::_Concurrent_vector_base_v4;

Parameter

T
Der Datentyp der Elemente, die im Vektor gespeichert werden sollen.

_Ax
Der Typ, der das gespeicherte Allocator-Objekt darstellt, das Details zur Speicherzuweisung und -freigabe für den concurrent vector kapselt. Dieses Argument ist optional, und der Standardwert ist allocator<T>.

Mitglieder

Öffentliche Typedefs

Öffentliche Konstruktoren

Öffentliche Methoden

Öffentliche Operatoren

Hinweise

Ausführliche Informationen zur concurrent_vector Klasse finden Sie unter Parallel Containers and Objects.

Vererbungshierarchie

_Concurrent_vector_base_v4

_Allocator_base

concurrent_vector

Anforderungen

Kopfzeile: concurrent_vector.h

Namespace: Parallelität

Zuweisen

Löscht die Elemente des nebenläufigen Vektors und weist ihm entweder _N Kopien von _Item zu, oder aus Werten, die vom Iteratorbereich [ _Begin, _End) stammen. Diese Methode ist nicht nebenläufigkeitssicher.

void assign(
    size_type _N,
    const_reference _Item);

template<class _InputIterator>
void assign(_InputIterator _Begin,
    _InputIterator _End);

Parameter

_InputIterator
Der Typ des angegebenen Iterators.

_N
Die Anzahl der Elemente, die in den gleichzeitigen Vektor kopiert werden sollen.

_Artikel
Bezug auf einen Wert, der zum Ausfüllen des nebenläufigen Vektors verwendet wird.

_Anfangen
Ein Iterator für das erste Element des Quellbereichs.

_Ende
Ein Iterator auf eins über das letzte Element des Quellbereichs.

Hinweise

assign ist nicht gleichzeitig sicher. Sie müssen sicherstellen, dass beim Aufrufen dieser Methode keine anderen Threads Methoden für den gleichzeitigen Vektor aufrufen.

bei

Ermöglicht den Zugriff auf das Element im angegebenen Index im gleichzeitigen Vektor. Diese Methode ist threadsicher für Lesevorgänge und auch beim Erweitern des Vektors, solange Sie sichergestellt haben, dass der Wert _Index kleiner als die Größe des parallelen Vektors ist.

reference at(size_type _Index);

const_reference at(size_type _Index) const;

Parameter

_Index
Der Index des abzurufenden Elements.

Rückgabewert

Ein Verweis auf das Element im angegebenen Index.

Hinweise

Die Version der Funktion at, die einen Verweis zurückgibt, der kein const ist, kann nicht verwendet werden, um aus verschiedenen Threads gleichzeitig auf das Element zuzugreifen und zu schreiben. Ein anderes Synchronisierungsobjekt sollte verwendet werden, um gleichzeitige Lese- und Schreibvorgänge mit demselben Datenelement zu synchronisieren.

Die Methode wirft out_of_range, wenn _Index größer oder gleich der Größe des konkurrierenden Vektors ist, und range_error, wenn der Index für einen beschädigten Abschnitt des Vektors steht. Ausführliche Informationen dazu, wie ein Vektor beschädigt werden kann, finden Sie unter parallele Container und Objekte.

Zurück

Gibt einen Verweis oder einen const Verweis auf das letzte Element im gleichzeitigen Vektor zurück. Wenn der gleichzeitige Vektor leer ist, ist der Rückgabewert nicht definiert. Diese Methode ist nebenläufigkeitssicher.

reference back();

const_reference back() const;

Rückgabewert

Ein Verweis oder ein const Verweis auf das letzte Element im Parallelvektor.

starten

Gibt einen Iterator vom Typ iterator oder const_iterator an den Anfang des gleichzeitigen Vektors zurück. Diese Methode ist nebenläufigkeitssicher.

iterator begin();

const_iterator begin() const;

Rückgabewert

Ein Iterator vom Typ iterator oder const_iterator zum Anfang des konkurrenten Vektors.

Kapazität

Gibt die maximale Größe zurück, auf die der gleichzeitige Vektor wachsen kann, ohne mehr Arbeitsspeicher zuweisen zu müssen. Diese Methode ist nebenläufigkeitssicher.

size_type capacity() const;

Rückgabewert

Die maximale Größe, auf die der gleichzeitige Vektor wachsen kann, ohne mehr Arbeitsspeicher zuweisen zu müssen.

Hinweise

Im Gegensatz zu einer C++-Standardbibliothek vector verschiebt ein concurrent_vector Objekt vorhandene Elemente nicht, wenn es mehr Speicher zuweist.

cbegin

Gibt einen Iterator vom Typ const_iterator an den Anfang des gleichzeitigen Vektors zurück. Diese Methode ist nebenläufigkeitssicher.

const_iterator cbegin() const;

Rückgabewert

Ein Iterator vom Typ const_iterator zum Anfang des Concurrent Vectors.

cend

Gibt einen Iterator vom Typ const_iterator bis zum Ende des konkurrierenden Vektors zurück. Diese Methode ist nebenläufigkeitssicher.

const_iterator cend() const;

Rückgabewert

Ein Iterator des Typs const_iterator bis zum Ende des Concurrent-Vektors.

klar

Löscht alle Elemente im gleichzeitigen Vektor. Diese Methode ist nicht nebenläufigkeitssicher.

void clear();

Hinweise

clear ist nicht gleichzeitig sicher. Sie müssen sicherstellen, dass beim Aufrufen dieser Methode keine anderen Threads Methoden für den gleichzeitigen Vektor aufrufen. clear gibt interne Arrays nicht frei. Rufen Sie zum Freigeben interner Arrays die Funktion shrink_to_fit nach clear.

concurrent_vector

Erstellt einen konkurrenten Vektor.

explicit concurrent_vector(
    const allocator_type& _Al = allocator_type());

concurrent_vector(
    const concurrent_vector& _Vector);

template<class M>
concurrent_vector(
    const concurrent_vector<T,
    M>& _Vector,
    const allocator_type& _Al = allocator_type());

concurrent_vector(
    concurrent_vector&& _Vector);

explicit concurrent_vector(
    size_type _N);

concurrent_vector(
    size_type _N,
    const_reference _Item,
    const allocator_type& _Al = allocator_type());

template<class _InputIterator>
concurrent_vector(_InputIterator _Begin,
    _InputIterator _End,
    const allocator_type& _Al = allocator_type());

Parameter

M
Der Allokator-Typ des Quellvektors.

_InputIterator
Der Typ des Eingabeiterators.

_Al
Die mit diesem Objekt zu verwendende Zuweisungsklasse.

_Vektor
Das concurrent_vector-Quellobjekt, aus dem Elemente kopiert oder verschoben werden sollen.

_N
Die Anfangskapazität des concurrent_vector-Objekts.

_Artikel
Der Wert der Elemente im erstellten Objekt.

_Anfangen
Die Position des ersten Elements in dem zu kopierenden Elementbereich.

_Ende
Die Position des ersten Elements, das sich jenseits des zu kopierenden Elementbereichs befindet.

Hinweise

Von allen Konstruktoren wird ein _Al-Zuweisungsobjekt gespeichert und der Vektor initialisiert.

Der erste Konstruktor gibt einen leeren Anfangsvektor an und gibt explizit den Allocatortyp an. zu verwenden.

Die zweiten und dritten Konstruktoren geben eine Kopie des parallel ausgeführten _Vector-Vektors an.

Der vierte Konstruktor gibt eine Verschiebung des gleichzeitigen _Vector-Vektors an.

Der fünfte Konstruktor gibt eine Wiederholung einer angegebenen Zahl (_N) von Elementen des Standardwerts für die Klasse Tan.

Der sechste Konstruktor gibt eine Wiederholung von (_N) Elementen des Werts _Iteman.

Der letzte Konstruktor gibt Werte an, die durch den Iteratorbereich [ _Begin, _End) bereitgestellt werden.

~concurrent_vector

Löscht alle Elemente und zerstört diesen gleichzeitigen Vektor.

~concurrent_vector();

crbegin

Gibt einen Iterator vom Typ const_reverse_iterator an den Anfang des gleichzeitigen Vektors zurück. Diese Methode ist nebenläufigkeitssicher.

const_reverse_iterator crbegin() const;

Rückgabewert

Ein Iterator vom Typ const_reverse_iterator zum Anfang des Concurrent Vectors.

Crend

Gibt einen Iterator vom Typ const_reverse_iterator bis zum Ende des konkurrenten Vektors zurück. Diese Methode ist nebenläufigkeitssicher.

const_reverse_iterator crend() const;

Rückgabewert

Ein Iterator des Typs const_reverse_iterator bis zum Ende des Concurrent-Vektors.

leer

Testet, ob der gleichzeitige Vektor zum Zeitpunkt des Aufrufs dieser Methode leer ist. Diese Methode ist nebenläufigkeitssicher.

bool empty() const;

Rückgabewert

true wenn der Vektor im Moment leer war, wurde die Funktion aufgerufen, false andernfalls.

Ende

Gibt einen Iterator vom Typ iterator oder const_iterator an das Ende des gleichzeitigen Vektors zurück. Diese Methode ist nebenläufigkeitssicher.

iterator end();

const_iterator end() const;

Rückgabewert

Ein Iterator vom Typ iterator oder const_iterator bis zum Ende des parallelen Vektors.

Vorderseite

Gibt einen Verweis oder einen const Verweis auf das erste Element im gleichzeitigen Vektor zurück. Wenn der gleichzeitige Vektor leer ist, ist der Rückgabewert nicht definiert. Diese Methode ist nebenläufigkeitssicher.

reference front();

const_reference front() const;

Rückgabewert

Ein Verweis oder ein const Verweis auf das erste Element im gleichzeitigen Vektor.

get_allocator

Gibt eine Kopie des Allocators zurück, der zum Konstruieren des gleichzeitigen Vektors verwendet wird. Diese Methode ist nebenläufigkeitssicher.

allocator_type get_allocator() const;

Rückgabewert

Eine Kopie des Allocators, der zum Konstruieren des concurrent_vector Objekts verwendet wird.

grow_by

Erweitert dieser konkurrente Vektor um _Delta Elemente. Diese Methode ist nebenläufigkeitssicher.

iterator grow_by(
    size_type _Delta);

iterator grow_by(
    size_type _Delta,
    const_reference _Item);

Parameter

_Delta
Die Anzahl der Elemente, die an das Objekt angefügt werden sollen.

_Artikel
Der Wert, mit dem die neuen Elemente initialisiert werden sollen.

Rückgabewert

Ein Iterator für das erste angefügte Element.

Hinweise

Wenn _Item nicht angegeben, werden die neuen Elemente standardmäßig konstruiert.

wachse_zu_mindestens

Wächst dieser gleichzeitige Vektor, bis er mindestens _N Elemente enthält. Diese Methode ist nebenläufigkeitssicher.

iterator grow_to_at_least(size_type _N);

Parameter

_N
Die neue Mindestgröße für das concurrent_vector Objekt.

Rückgabewert

Ein Iterator, der auf den Anfang der angefügten Sequenz oder auf das Element am Index _N zeigt, wenn keine Elemente angefügt wurden.

Maximalgröße

Gibt die maximale Anzahl von Elementen zurück, die der gleichzeitige Vektor enthalten kann. Diese Methode ist nebenläufigkeitssicher.

size_type max_size() const;

Rückgabewert

Die maximale Anzahl von Elementen, die das concurrent_vector Objekt enthalten kann.

operator =

Weist den Inhalt eines anderen concurrent_vector-Objekts diesem Objekt zu. Diese Methode ist nicht nebenläufigkeitssicher.

concurrent_vector& operator= (
    const concurrent_vector& _Vector);

template<class M>
concurrent_vector& operator= (
    const concurrent_vector<T, M>& _Vector);

concurrent_vector& operator= (
    concurrent_vector&& _Vector);

Parameter

M
Der Allokator-Typ des Quellvektors.

_Vektor
Das concurrent_vector-Quellobjekt.

Rückgabewert

Ein Verweis auf das concurrent_vector-Objekt.

operator[]

Ermöglicht den Zugriff auf das Element im angegebenen Index im gleichzeitigen Vektor. Diese Methode ist für Lesevorgänge gleichzeitig sicher und auch beim Vergrößern des Vektors, solange Sie sichergestellt haben, dass der Wert _Index kleiner als die Größe des gleichzeitigen Vektors ist.

reference operator[](size_type _index);

const_reference operator[](size_type _index) const;

Parameter

_Index
Der Index des abzurufenden Elements.

Rückgabewert

Ein Verweis auf das Element im angegebenen Index.

Hinweise

Die Version von operator [], die eine nicht-const-Referenz zurückgibt, kann nicht verwendet werden, um gleichzeitig aus verschiedenen Threads auf das Element zu schreiben. Ein anderes Synchronisierungsobjekt sollte verwendet werden, um gleichzeitige Lese- und Schreibvorgänge mit demselben Datenelement zu synchronisieren.

Es wird nicht überprüft, ob _Index ein gültiger Index im gleichzeitigen Vektor ist, da keine Begrenzungsüberprüfung erfolgt.

push_back

Fügt das angegebene Element am Ende des nebenläufigen Vektors hinzu. Diese Methode ist nebenläufigkeitssicher.

iterator push_back(const_reference _Item);

iterator push_back(T&& _Item);

Parameter

_Artikel
Der Wert, der angefügt werden soll.

Rückgabewert

Ein Iterator auf das angehängte Element.

rbegin

Gibt einen Iterator vom Typ reverse_iterator oder const_reverse_iterator an den Anfang des gleichzeitigen Vektors zurück. Diese Methode ist nebenläufigkeitssicher.

reverse_iterator rbegin();

const_reverse_iterator rbegin() const;

Rückgabewert

Ein Iterator vom Typ reverse_iterator oder const_reverse_iterator zum Anfang des konkurrenten Vektors.

reißen

Gibt einen Iterator vom Typ reverse_iterator oder const_reverse_iterator an das Ende des gleichzeitigen Vektors zurück. Diese Methode ist nebenläufigkeitssicher.

reverse_iterator rend();

const_reverse_iterator rend() const;

Rückgabewert

Ein Iterator vom Typ reverse_iterator oder const_reverse_iterator bis zum Ende des parallelen Vektors.

Reserve

Weist genügend Speicherplatz zu, um die Größe _N des gleichzeitigen Vektors zu vergrößern, ohne später mehr Arbeitsspeicher zuweisen zu müssen. Diese Methode ist nicht nebenläufigkeitssicher.

void reserve(size_type _N);

Parameter

_N
Die Anzahl der Elemente, für die Platz reserviert werden soll.

Hinweise

reserve ist nicht gleichzeitig sicher. Sie müssen sicherstellen, dass beim Aufrufen dieser Methode keine anderen Threads Methoden für den gleichzeitigen Vektor aufrufen. Die Kapazität des gemeinsamen Vektors, nachdem die Methode abgeschlossen ist, kann größer als die angeforderte Reservierung sein.

Größe ändern

Ändert die Größe des Concurrent Vector auf die angeforderte Größe, indem bei Bedarf Elemente gelöscht oder hinzugefügt werden. Diese Methode ist nicht nebenläufigkeitssicher.

void resize(
    size_type _N);

void resize(
    size_type _N,
    const T& val);

Parameter

_N
Die neue Größe des concurrent_vector.

Val
Der Wert neuer Elemente, die dem Vektor hinzugefügt werden, wenn die neue Größe größer als die originale Größe ist. Wenn der Wert nicht angegeben wird, werden den neuen Objekten der Standardwert für ihren Typ zugewiesen.

Hinweise

Wenn die Größe des Containers kleiner als die angeforderte Größe ist, werden elemente dem Vektor hinzugefügt, bis sie die angeforderte Größe erreicht. Wenn die Größe des Containers größer als die angeforderte Größe ist, werden die Am nächsten am Ende des Containers liegenden Elemente gelöscht, bis der Container die Größe _Nerreicht. Wenn die tatsächliche Größe des Containers der angeforderten Größe entspricht, wird keine Aktion durchgeführt.

resize ist nicht threadsicher. Sie müssen sicherstellen, dass beim Aufrufen dieser Methode keine anderen Threads Methoden für den gleichzeitigen Vektor aufrufen.

shrink_to_fit

Komprimiert die interne Darstellung des gleichzeitigen Vektors, um die Fragmentierung zu reduzieren und die Speicherauslastung zu optimieren. Diese Methode ist nicht nebenläufigkeitssicher.

void shrink_to_fit();

Hinweise

Mit dieser Methode werden intern Speicherverschiebungselemente neu zugewiesen, wobei alle Iteratoren ungültig werden. shrink_to_fit ist nicht gleichzeitig sicher. Sie müssen sicherstellen, dass beim Aufrufen dieser Funktion keine anderen Threads Methoden für den gleichzeitigen Vektor aufrufen.

Größe

Gibt die Anzahl der Elemente im gleichzeitigen Vektor zurück. Diese Methode ist nebenläufigkeitssicher.

size_type size() const;

Rückgabewert

Die Anzahl der Elemente in diesem concurrent_vector Objekt.

Hinweise

Die zurückgegebene Größe schließt garantiert alle Elemente ein, die durch Aufrufe der Funktion push_back angefügt wurden, oder Erweiterungsoperationen, die vor dem Aufruf dieser Methode abgeschlossen wurden. Es kann jedoch auch Elemente enthalten, die zugewiesen werden, sich aber noch im Aufbau befinden, durch gleichzeitige Aufrufe an eine der Wachstumsmethoden.

austauschen

Tauscht den Inhalt von zwei gleichzeitigen Vektoren. Diese Methode ist nicht nebenläufigkeitssicher.

void swap(concurrent_vector& _Vector);

Parameter

_Vektor
Das concurrent_vector Objekt, mit dem Inhalte ausgetauscht werden sollen.

Siehe auch

Concurrency-Namespace
Parallele Container und Objekte