Classe concurrent_vector

La classe concurrent_vector è una classe contenitore di sequenze che consente un accesso casuale a qualsiasi elemento. Abilita operazioni di accodamento, accesso agli elementi, accesso agli iteratori e di attraversamento degli iteratori sicure per la concorrenza. In questo caso, i puntatori o gli iteratori sicuri per l'uso concorrente sono sempre validi. Non è una garanzia di inizializzazione degli elementi o di un ordine di attraversamento specifico.

Sintassi

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

Parametri

T
Tipo di dati degli elementi da archiviare nel vettore.

_Asse
Tipo che rappresenta l'oggetto allocatore archiviato che incapsula i dettagli sull'allocazione e la deallocazione della memoria per il vettore simultaneo. Questo argomento è facoltativo e il valore predefinito è allocator<T>.

Membri

Typedef pubblici

Costruttori pubblici

Metodi pubblici

Operatori pubblici

Osservazioni:

Per informazioni dettagliate sulla concurrent_vector classe , vedere Contenitori e oggetti paralleli.

Gerarchia di ereditarietà

_Concurrent_vector_base_v4

_Allocator_base

concurrent_vector

Requisiti

Intestazione: concurrent_vector.h

Spazio dei nomi: Concurrency

assegnare

Cancella gli elementi del vettore simultaneo e gli assegna copie _N di _Itemo valori specificati dall'intervallo iteratore [ _Begin, _End). Questo metodo non è sicuro per la concorrenza.

void assign(
    size_type _N,
    const_reference _Item);

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

Parametri

_InputIterator
Tipo dell'iteratore specificato.

_N
Numero di elementi da copiare nel vettore simultaneo.

_Articolo
Riferimento a un valore utilizzato per riempire il vettore simultaneo.

_Cominciare
Iteratore al primo elemento dell'intervallo di origine.

_Fine
Iteratore che supera l'ultimo elemento dell'intervallo di origine.

Osservazioni:

assign non è indipendente dalla concorrenza. È necessario assicurarsi che nessun altro thread richiami metodi sul vettore simultaneo quando si chiama questo metodo.

alle

Fornisce l'accesso all'elemento in corrispondenza dell'indice specificato nel vettore simultaneo. Questo metodo è sicuro per la concorrenza per le operazioni di lettura e anche durante la crescita del vettore, purché sia stato garantito che il valore _Index sia minore della dimensione del vettore concorrente.

reference at(size_type _Index);

const_reference at(size_type _Index) const;

Parametri

_Indice
Indice dell'elemento da recuperare.

Valore restituito

Riferimento all'elemento in corrispondenza dell'indice specificato.

Osservazioni:

La versione della funzione at che restituisce un riferimento diverso da const non può essere utilizzata per scrivere contemporaneamente nell'elemento da thread diversi. È necessario utilizzare un oggetto di sincronizzazione diverso per sincronizzare le operazioni di lettura e scrittura simultanee con lo stesso elemento dati.

Il metodo genera out_of_range se _Index è maggiore o uguale alla dimensione del vettore simultaneo e range_error se l'indice è per una parte interrotta del vettore. Per informazioni dettagliate su come un vettore può diventare interrotto, vedere Contenitori e oggetti paralleli.

Indietro

Restituisce un riferimento o un const riferimento all'ultimo elemento nel vettore simultaneo. Se il vettore simultaneo è vuoto, il valore restituito non è definito. Questo metodo è sicuro per la concorrenza.

reference back();

const_reference back() const;

Valore restituito

Riferimento o riferimento const all'ultimo elemento nel vettore simultaneo.

cominciare

Restituisce un iteratore di tipo iterator o const_iterator all'inizio del vettore simultaneo. Questo metodo è sicuro per la concorrenza.

iterator begin();

const_iterator begin() const;

Valore restituito

Iteratore di tipo iterator o const_iterator all'inizio del vettore simultaneo.

capacità

Restituisce le dimensioni massime a cui il vettore simultaneo può crescere senza dover allocare più memoria. Questo metodo è sicuro per la concorrenza.

size_type capacity() const;

Valore restituito

Dimensione massima raggiungibile dal vettore simultaneo senza dover allocare altra memoria.

Osservazioni:

A differenza di una libreria vectorstandard C++, un concurrent_vector oggetto non sposta gli elementi esistenti se alloca più memoria.

cbegin

Restituisce un iteratore di tipo const_iterator all'inizio del vettore simultaneo. Questo metodo è sicuro per la concorrenza.

const_iterator cbegin() const;

Valore restituito

Iteratore di tipo const_iterator all'inizio del vettore simultaneo.

cend

Restituisce un iteratore di tipo const_iterator alla fine del vettore simultaneo. Questo metodo è sicuro per la concorrenza.

const_iterator cend() const;

Valore restituito

Iteratore di tipo const_iterator alla fine del vettore simultaneo.

chiaro

Cancella tutti gli elementi nel vettore simultaneo. Questo metodo non è sicuro per la concorrenza.

void clear();

Osservazioni:

clear non è indipendente dalla concorrenza. È necessario assicurarsi che nessun altro thread richiami metodi sul vettore simultaneo quando si chiama questo metodo. clear non libera matrici interne. Per liberare matrici interne, chiamare la funzione shrink_to_fit dopo clear.

concurrent_vector

Costruisce un vettore concorrente.

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());

Parametri

M
Tipo di allocatore del vettore di origine.

_InputIterator
Tipo di iteratore di input.

_Ale
Classe Allocator da usare con questo oggetto.

_Vettore
Oggetto concurrent_vector di origine da cui copiare o spostare elementi.

_N
Capacità iniziale dell'oggetto concurrent_vector.

_Articolo
Valore degli elementi nell'oggetto costruito.

_Cominciare
Posizione del primo elemento nell'intervallo di elementi da copiare.

_Fine
Posizione del primo elemento oltre l'intervallo di elementi da copiare.

Osservazioni:

Tutti i costruttori archiviano un oggetto _Al allocatore e inizializzano il vettore.

Il primo costruttore specifica un vettore iniziale vuoto e specifica in modo esplicito il tipo di allocatore. da utilizzare.

Il secondo e il terzo costruttore specificano una copia del vettore _Vector concorrenziale.

Tramite il quarto costruttore viene specificato un movimento del vettore simultaneo _Vector.

Il quinto costruttore specifica una ripetizione di un numero specificato (_N) di elementi del valore predefinito per la classe T.

Il sesto costruttore specifica una ripetizione di elementi (_N) di valore _Item.

L'ultimo costruttore specifica i valori forniti dall'intervallo di iteratori [ _Begin, _End).

~concurrent_vector

Cancella tutti gli elementi e distrugge questo vettore simultaneo.

~concurrent_vector();

crbegin

Restituisce un iteratore di tipo const_reverse_iterator all'inizio del vettore simultaneo. Questo metodo è sicuro per la concorrenza.

const_reverse_iterator crbegin() const;

Valore restituito

Iteratore di tipo const_reverse_iterator all'inizio del vettore simultaneo.

crend

Restituisce un iteratore di tipo const_reverse_iterator alla fine del vettore simultaneo. Questo metodo è sicuro per la concorrenza.

const_reverse_iterator crend() const;

Valore restituito

Iteratore di tipo const_reverse_iterator alla fine del vettore simultaneo.

vuoto

Verifica se il vettore simultaneo è vuoto al momento della chiamata di questo metodo. Questo metodo è sicuro per la concorrenza.

bool empty() const;

Valore restituito

true se il vettore è vuoto nel momento in cui la funzione è stata chiamata, false in caso contrario.

fine

Restituisce un iteratore di tipo iterator o const_iterator alla fine del vettore simultaneo. Questo metodo è sicuro per la concorrenza.

iterator end();

const_iterator end() const;

Valore restituito

Iteratore di tipo iterator o const_iterator alla fine del vettore simultaneo.

fronte

Restituisce un riferimento o un const riferimento al primo elemento nel vettore simultaneo. Se il vettore simultaneo è vuoto, il valore restituito non è definito. Questo metodo è sicuro per la concorrenza.

reference front();

const_reference front() const;

Valore restituito

Riferimento o const riferimento al primo elemento nel vettore concorrente.

get_allocator

Restituisce una copia dell'allocatore utilizzato per costruire il vettore simultaneo. Questo metodo è sicuro per la concorrenza.

allocator_type get_allocator() const;

Valore restituito

Copia dell'allocatore utilizzato per costruire l'oggetto concurrent_vector .

grow_by

Aumenta questo vettore simultaneo aggiungendo _Delta elementi. Questo metodo è sicuro per la concorrenza.

iterator grow_by(
    size_type _Delta);

iterator grow_by(
    size_type _Delta,
    const_reference _Item);

Parametri

_Delta
Numero di elementi da accodare all'oggetto.

_Articolo
Valore con cui inizializzare i nuovi elementi.

Valore restituito

Iteratore al primo elemento aggiunto.

Osservazioni:

Se _Item non viene specificato, i nuovi elementi vengono costruiti per impostazione predefinita.

crescere_fino_almeno

Aumenta questo vettore concorrenziale fino a raggiungere almeno _N elementi. Questo metodo è sicuro per la concorrenza.

iterator grow_to_at_least(size_type _N);

Parametri

_N
Nuova dimensione minima per l'oggetto concurrent_vector .

Valore restituito

Iteratore che punta all'inizio della sequenza accodata o all'elemento in corrispondenza dell'indice _N se non sono stati aggiunti elementi.

dimensione_massima

Restituisce il numero massimo di elementi che il vettore simultaneo può contenere. Questo metodo è sicuro per la concorrenza.

size_type max_size() const;

Valore restituito

Numero massimo di elementi che l'oggetto concurrent_vector può contenere.

operator=

Assegna il contenuto di un altro concurrent_vector oggetto a questo oggetto. Questo metodo non è sicuro per la concorrenza.

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);

Parametri

M
Tipo di allocatore del vettore di origine.

_Vettore
Oggetto concurrent_vector di origine.

Valore restituito

Riferimento a questo concurrent_vector oggetto.

operator[]

Fornisce l'accesso all'elemento in corrispondenza dell'indice specificato nel vettore simultaneo. Questo metodo è sicuro in caso di concorrenza per le operazioni di lettura e anche durante la crescita del vettore, purché il valore _Index sia minore della dimensione del vettore concorrente.

reference operator[](size_type _index);

const_reference operator[](size_type _index) const;

Parametri

_Indice
Indice dell'elemento da recuperare.

Valore restituito

Riferimento all'elemento in corrispondenza dell'indice specificato.

Osservazioni:

La versione di operator [] che restituisce un riferimento non const non può essere utilizzata per scrivere simultaneamente nell'elemento da thread diversi. È necessario utilizzare un oggetto di sincronizzazione diverso per sincronizzare le operazioni di lettura e scrittura simultanee con lo stesso elemento dati.

Non viene eseguito alcun controllo dei limiti per assicurarsi che _Index sia un indice valido nel vettore simultaneo.

push_back (metodo C++ per aggiungere un elemento alla fine di un vettore)

Aggiunge l'elemento specificato alla fine del vettore simultaneo. Questo metodo è sicuro per la concorrenza.

iterator push_back(const_reference _Item);

iterator push_back(T&& _Item);

Parametri

_Articolo
Valore da accodare.

Valore restituito

Iteratore per l'elemento aggiunto.

rbegin

Restituisce un iteratore di tipo reverse_iterator o const_reverse_iterator all'inizio del vettore simultaneo. Questo metodo è sicuro per la concorrenza.

reverse_iterator rbegin();

const_reverse_iterator rbegin() const;

Valore restituito

Iteratore di tipo reverse_iterator o const_reverse_iterator all'inizio del vettore simultaneo.

strappare

Restituisce un iteratore di tipo reverse_iterator o const_reverse_iterator alla fine del vettore simultaneo. Questo metodo è sicuro per la concorrenza.

reverse_iterator rend();

const_reverse_iterator rend() const;

Valore restituito

Iteratore di tipo reverse_iterator o const_reverse_iterator alla fine del vettore simultaneo.

riservare

Alloca spazio sufficiente per aumentare le dimensioni _N del vettore simultaneo senza dover allocare più memoria in un secondo momento. Questo metodo non è sicuro per la concorrenza.

void reserve(size_type _N);

Parametri

_N
Numero di elementi per cui riservare spazio.

Osservazioni:

reserve non è indipendente dalla concorrenza. È necessario assicurarsi che nessun altro thread richiami metodi sul vettore simultaneo quando si chiama questo metodo. La capacità del vettore concorrente dopo il ritorno del metodo potrebbe essere maggiore rispetto alla riserva richiesta.

Ridimensionare

Modifica le dimensioni del vettore simultaneo in base alle dimensioni richieste, eliminando o aggiungendo elementi in base alle esigenze. Questo metodo non è sicuro per la concorrenza.

void resize(
    size_type _N);

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

Parametri

_N
Nuova dimensione di concurrent_vector.

val
Valore di nuovi elementi aggiunti al vettore se la nuova dimensione è maggiore di quella originale. Se il valore viene omesso, ai nuovi oggetti viene assegnato il valore predefinito per il tipo.

Osservazioni:

Se le dimensioni del contenitore sono inferiori alle dimensioni richieste, gli elementi vengono aggiunti al vettore fino a raggiungere le dimensioni richieste. Se le dimensioni del contenitore sono maggiori delle dimensioni richieste, gli elementi più vicini alla fine del contenitore vengono eliminati fino a quando il contenitore non raggiunge le dimensioni _N. Se la dimensione attuale del contenitore corrisponde a quella richiesta, non viene eseguita alcuna azione.

resize non è sicuro per la concorrenza. È necessario assicurarsi che nessun altro thread richiami metodi sul vettore simultaneo quando si chiama questo metodo.

riduci_per_adattare

Compatta la rappresentazione interna del vettore simultaneo per ridurre la frammentazione e ottimizzare l'utilizzo della memoria. Questo metodo non è sicuro per la concorrenza.

void shrink_to_fit();

Osservazioni:

Questo metodo riassegnerà internamente la memoria spostando gli elementi, invalidando tutti gli iteratori. shrink_to_fit non è indipendente dalla concorrenza. È necessario assicurarsi che nessun altro thread richiami metodi sul vettore simultaneo quando si chiama questa funzione.

dimensione / taglia

Restituisce il numero di elementi nel vettore simultaneo. Questo metodo è sicuro per la concorrenza.

size_type size() const;

Valore restituito

Numero di elementi in questo concurrent_vector oggetto.

Osservazioni:

La dimensione restituita è garantita di includere tutti gli elementi aggiunti dalle chiamate alla funzione push_backo le operazioni di aumento completate prima di richiamare questo metodo. Tuttavia, può anche includere elementi allocati ma ancora in corso di costruzione a causa di chiamate simultanee a qualsiasi dei metodi di crescita.

scambio

Scambia il contenuto di due vettori simultanei. Questo metodo non è sicuro per la concorrenza.

void swap(concurrent_vector& _Vector);

Parametri

_Vettore
Oggetto concurrent_vector con cui scambiare il contenuto.

Vedi anche

Spazio dei nomi concorrenza
Contenitori e oggetti paralleli