Partager via

Classe concurrent_vector

  • Article

La classe concurrent_vector est une classe de conteneur de séquence qui autorise un accès aléatoire à tout élément. Elle permet les opérations d'ajout d'accès concurrentiel sécurisé, d'accès à un élément, d'accès à un itérateur et de traversée d'itérateur. Ici, la concurrence-safe signifie que les pointeurs ou les itérateurs sont toujours valides. Il ne s’agit pas d’une garantie d’initialisation d’élément ou d’un ordre de traversée particulier.

Syntaxe

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

Paramètres

T
Type de données des éléments à stocker dans le vecteur.

_Ax
Type qui représente l’objet allocator stocké qui encapsule les détails sur l’allocation et la désallocation de la mémoire pour le vecteur simultané. Cet argument est facultatif et sa valeur par défaut est allocator<T>.

Membres

Typedefs publics

Nom Description
allocator_type Type qui représente la classe d’allocator pour le vecteur simultané.
const_iterator Type qui fournit un itérateur d’accès aléatoire qui peut lire un const élément dans un vecteur simultané.
const_pointer Type qui fournit un pointeur vers un const élément dans un vecteur simultané.
const_reference Type qui fournit une référence à un const élément stocké dans un vecteur simultané pour la lecture et l’exécution d’opérations const .
const_reverse_iterator Type qui fournit un itérateur d’accès aléatoire qui peut lire n’importe quel const élément dans le vecteur simultané.
difference_type Type qui fournit la distance signée entre deux éléments dans un vecteur simultané.
iterator Type qui fournit un itérateur d’accès aléatoire qui peut lire n’importe quel élément dans un vecteur simultané. La modification d’un élément à l’aide de l’itérateur n’est pas sécurisée par concurrence.
pointer Type qui fournit un pointeur vers un élément dans un vecteur simultané.
reference Type qui fournit une référence à un élément stocké dans un vecteur simultané.
reverse_iterator Type qui fournit un itérateur d’accès aléatoire qui peut lire n’importe quel élément dans un vecteur simultané inversé. La modification d’un élément à l’aide de l’itérateur n’est pas sécurisée par concurrence.
size_type Type qui compte le nombre d’éléments dans un vecteur simultané.
value_type Type qui représente le type de données stocké dans un vecteur simultané.

Constructeurs publics

Nom Description
concurrent_vector Surcharge. Construit un vecteur simultané.
~concurrent_vector Destructeur Efface tous les éléments et détruit ce vecteur simultané.

Méthodes publiques

Nom Description
assign Surcharge. Efface les éléments du vecteur simultané et lui affecte des _N copies ou _Itemdes valeurs spécifiées par la plage d’itérateur [ _Begin, _End). Cette méthode n’est pas sécurisée par concurrence.
at Surcharge. Fournit l’accès à l’élément à l’index donné dans le vecteur simultané. Cette méthode est sécurisée par la concurrence pour les opérations de lecture, et également lors de la croissance du vecteur, tant que vous avez vérifié que la valeur _Index est inférieure à la taille du vecteur simultané.
back Surcharge. Retourne une référence ou une const référence au dernier élément du vecteur simultané. Si le vecteur simultané est vide, la valeur de retour n’est pas définie. Cette méthode est concurrency-safe.
begin Surcharge. Retourne un itérateur de type iterator ou const_iterator au début du vecteur simultané. Cette méthode est concurrency-safe.
capacité Retourne la taille maximale à laquelle le vecteur simultané peut croître sans avoir à allouer plus de mémoire. Cette méthode est concurrency-safe.
cbegin Retourne un itérateur de type const_iterator au début du vecteur simultané. Cette méthode est concurrency-safe.
cend Retourne un itérateur de type const_iterator à la fin du vecteur simultané. Cette méthode est concurrency-safe.
clear Efface tous les éléments du vecteur simultané. Cette méthode n’est pas sécurisée par concurrence.
crbegin Retourne un itérateur de type const_reverse_iterator au début du vecteur simultané. Cette méthode est concurrency-safe.
crend Retourne un itérateur de type const_reverse_iterator à la fin du vecteur simultané. Cette méthode est concurrency-safe.
empty Teste si le vecteur simultané est vide au moment où cette méthode est appelée. Cette méthode est concurrency-safe.
end Surcharge. Retourne un itérateur de type iterator ou const_iterator à la fin du vecteur simultané. Cette méthode est concurrency-safe.
front Surcharge. Retourne une référence ou une const référence au premier élément du vecteur simultané. Si le vecteur simultané est vide, la valeur de retour n’est pas définie. Cette méthode est concurrency-safe.
get_allocator Retourne une copie de l’allocateur utilisé pour construire le vecteur simultané. Cette méthode est concurrency-safe.
grow_by Surcharge. Augmente ce vecteur simultané par _Delta des éléments. Cette méthode est concurrency-safe.
grow_to_at_least Augmente ce vecteur simultané jusqu’à ce qu’il ait au moins _N des éléments. Cette méthode est concurrency-safe.
max_size Retourne le nombre maximal d’éléments que le vecteur simultané peut contenir. Cette méthode est concurrency-safe.
push_back Surcharge. Ajoute l’élément donné à la fin du vecteur simultané. Cette méthode est concurrency-safe.
rbegin Surcharge. Retourne un itérateur de type reverse_iterator ou const_reverse_iterator au début du vecteur simultané. Cette méthode est concurrency-safe.
rend Surcharge. Retourne un itérateur de type reverse_iterator ou const_reverse_iterator à la fin du vecteur simultané. Cette méthode est concurrency-safe.
reserve Alloue suffisamment d’espace pour augmenter la taille _N du vecteur simultané sans avoir à allouer plus de mémoire ultérieurement. Cette méthode n’est pas sécurisée par concurrence.
resize Surcharge. Modifie la taille du vecteur simultané par la taille demandée, la suppression ou l’ajout d’éléments si nécessaire. Cette méthode n’est pas sécurisée par concurrence.
shrink_to_fit Compacte la représentation interne du vecteur simultané pour réduire la fragmentation et optimiser l’utilisation de la mémoire. Cette méthode n’est pas sécurisée par concurrence.
size Retourne le nombre d’éléments dans le vecteur simultané. Cette méthode est concurrency-safe.
swap Échange le contenu de deux vecteurs simultanés. Cette méthode n’est pas sécurisée par concurrence.

Opérateurs publics

Nom Description
operator[] Surcharge. Fournit l’accès à l’élément à l’index donné dans le vecteur simultané. Cette méthode est sécurisée par concurrence pour les opérations de lecture, et également lors de la croissance du vecteur, tant que vous avez vérifié que la valeur _Index est inférieure à la taille du vecteur simultané.
operator= Surcharge. Affecte le contenu d’un autre concurrent_vector objet à celui-ci. Cette méthode n’est pas sécurisée par concurrence.

Notes

Pour plus d’informations sur la concurrent_vector classe, consultez Conteneurs et objets parallèles.

Hiérarchie d'héritage

_Concurrent_vector_base_v4

_Allocator_base

concurrent_vector

Spécifications

En-tête : concurrent_vector.h

Espace de noms : concurrency

attribuer

Efface les éléments du vecteur simultané et lui affecte des _N copies ou _Itemdes valeurs spécifiées par la plage d’itérateur [ _Begin, _End). Cette méthode n’est pas sécurisée par concurrence.

void assign(
    size_type _N,
    const_reference _Item);

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

Paramètres

_InputIterator
Type de l’itérateur spécifié.

_¡n
Nombre d’éléments à copier dans le vecteur simultané.

_Article
Référence à une valeur utilisée pour remplir le vecteur simultané.

_Commencer
Itérateur vers le premier élément de la plage source.

_Fin
Itérateur vers un autre élément de la plage source.

Notes

assign n’est pas sécurisé par la concurrence. Vous devez vous assurer qu’aucun autre thread n’appelle des méthodes sur le vecteur simultané lorsque vous appelez cette méthode.

at

Fournit l’accès à l’élément à l’index donné dans le vecteur simultané. Cette méthode est sécurisée par la concurrence pour les opérations de lecture, et également lors de la croissance du vecteur, tant que vous avez vérifié que la valeur _Index est inférieure à la taille du vecteur simultané.

reference at(size_type _Index);

const_reference at(size_type _Index) const;

Paramètres

_Index
Index de l’élément à récupérer.

Valeur de retour

Référence à l’élément à l’index donné.

Notes

La version de la fonction at qui retourne une référence non-référencée const ne peut pas être utilisée simultanément pour écrire dans l’élément à partir de différents threads. Un objet de synchronisation différent doit être utilisé pour synchroniser les opérations de lecture et d’écriture simultanées dans le même élément de données.

La méthode lève out_of_range si _Index elle est supérieure ou égale à la taille du vecteur simultané, et range_error si l’index est pour une partie rompue du vecteur. Pour plus d’informations sur la façon dont un vecteur peut être rompu, consultez Conteneurs et objets parallèles.

Retour

Retourne une référence ou une const référence au dernier élément du vecteur simultané. Si le vecteur simultané est vide, la valeur de retour n’est pas définie. Cette méthode est concurrency-safe.

reference back();

const_reference back() const;

Valeur de retour

Référence ou const référence au dernier élément du vecteur simultané.

begin

Retourne un itérateur de type iterator ou const_iterator au début du vecteur simultané. Cette méthode est concurrency-safe.

iterator begin();

const_iterator begin() const;

Valeur de retour

Itérateur de type iterator ou const_iterator au début du vecteur simultané.

capacité

Retourne la taille maximale à laquelle le vecteur simultané peut croître sans avoir à allouer plus de mémoire. Cette méthode est concurrency-safe.

size_type capacity() const;

Valeur de retour

Taille maximale à laquelle le vecteur simultané peut croître sans avoir à allouer plus de mémoire.

Notes

Contrairement à une bibliothèque vectorstandard C++, un concurrent_vector objet ne déplace pas les éléments existants s’il alloue plus de mémoire.

cbegin

Retourne un itérateur de type const_iterator au début du vecteur simultané. Cette méthode est concurrency-safe.

const_iterator cbegin() const;

Valeur de retour

Itérateur de type const_iterator au début du vecteur simultané.

cend

Retourne un itérateur de type const_iterator à la fin du vecteur simultané. Cette méthode est concurrency-safe.

const_iterator cend() const;

Valeur de retour

Itérateur de type const_iterator à la fin du vecteur simultané.

clear

Efface tous les éléments du vecteur simultané. Cette méthode n’est pas sécurisée par concurrence.

void clear();

Notes

clear n’est pas sécurisé par la concurrence. Vous devez vous assurer qu’aucun autre thread n’appelle des méthodes sur le vecteur simultané lorsque vous appelez cette méthode. clear ne libère pas de tableaux internes. Pour libérer des tableaux internes, appelez la fonction shrink_to_fit après clear.

concurrent_vector

Construit un vecteur simultané.

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

Paramètres

M
Type d’allocator du vecteur source.

_InputIterator
Type de l'itérateur d'entrée.

_Al
Classe allocator à utiliser avec cet objet.

_Vecteur
Objet source concurrent_vector à partir duquel copier ou déplacer des éléments.

_¡n
Capacité initiale de l’objet concurrent_vector .

_Article
Valeur des éléments dans l’objet construit.

_Commencer
Position du premier élément dans la plage d'éléments à copier.

_Fin
Position du premier élément suivant la fin de la plage d'éléments à copier.

Notes

Tous les constructeurs stockent un objet _Al d’allocator et initialisent le vecteur.

Le premier constructeur spécifie un vecteur initial vide et spécifie explicitement le type d’allocator. à utiliser.

Les deuxième et troisième constructeurs spécifient une copie du vecteur _Vectorsimultané.

Le quatrième constructeur spécifie un déplacement du vecteur _Vectorsimultané.

Le cinquième constructeur spécifie une répétition d’un nombre ( _N) spécifié d’éléments de la valeur par défaut pour la classe T.

Le sixième constructeur spécifie une répétition des éléments ( _N) de valeur _Item.

Le dernier constructeur spécifie les valeurs fournies par la plage d’itérateurs [ _Begin, _End).

~concurrent_vector

Efface tous les éléments et détruit ce vecteur simultané.

~concurrent_vector();

crbegin

Retourne un itérateur de type const_reverse_iterator au début du vecteur simultané. Cette méthode est concurrency-safe.

const_reverse_iterator crbegin() const;

Valeur de retour

Itérateur de type const_reverse_iterator au début du vecteur simultané.

crend

Retourne un itérateur de type const_reverse_iterator à la fin du vecteur simultané. Cette méthode est concurrency-safe.

const_reverse_iterator crend() const;

Valeur de retour

Itérateur de type const_reverse_iterator à la fin du vecteur simultané.

empty

Teste si le vecteur simultané est vide au moment où cette méthode est appelée. Cette méthode est concurrency-safe.

bool empty() const;

Valeur de retour

true si le vecteur était vide au moment où la fonction a été appelée, false sinon.

end

Retourne un itérateur de type iterator ou const_iterator à la fin du vecteur simultané. Cette méthode est concurrency-safe.

iterator end();

const_iterator end() const;

Valeur de retour

Itérateur de type iterator ou const_iterator à la fin du vecteur simultané.

front

Retourne une référence ou une const référence au premier élément du vecteur simultané. Si le vecteur simultané est vide, la valeur de retour n’est pas définie. Cette méthode est concurrency-safe.

reference front();

const_reference front() const;

Valeur de retour

Référence ou const référence au premier élément du vecteur simultané.

get_allocator

Retourne une copie de l’allocateur utilisé pour construire le vecteur simultané. Cette méthode est concurrency-safe.

allocator_type get_allocator() const;

Valeur de retour

Copie de l’allocateur utilisé pour construire l’objet concurrent_vector .

grow_by

Augmente ce vecteur simultané par _Delta des éléments. Cette méthode est concurrency-safe.

iterator grow_by(
    size_type _Delta);

iterator grow_by(
    size_type _Delta,
    const_reference _Item);

Paramètres

_Delta
Nombre d’éléments à ajouter à l’objet.

_Article
Valeur à utiliser pour initialiser les nouveaux éléments.

Valeur de retour

Itérateur pour le premier élément ajouté.

Notes

Si _Item ce n’est pas spécifié, les nouveaux éléments sont construits par défaut.

grow_to_at_least

Augmente ce vecteur simultané jusqu’à ce qu’il ait au moins _N des éléments. Cette méthode est concurrency-safe.

iterator grow_to_at_least(size_type _N);

Paramètres

_¡n
Nouvelle taille minimale pour l’objet concurrent_vector .

Valeur de retour

Itérateur qui pointe vers le début de la séquence ajoutée ou à l’élément à l’index _N si aucun élément n’a été ajouté.

max_size

Retourne le nombre maximal d’éléments que le vecteur simultané peut contenir. Cette méthode est concurrency-safe.

size_type max_size() const;

Valeur de retour

Nombre maximal d’éléments que l’objet concurrent_vector peut contenir.

opérateur =

Affecte le contenu d’un autre concurrent_vector objet à celui-ci. Cette méthode n’est pas sécurisée par concurrence.

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

Paramètres

M
Type d’allocator du vecteur source.

_Vecteur
Objet concurrent_vector source.

Valeur de retour

Référence à cet concurrent_vector objet.

operator[]

Fournit l’accès à l’élément à l’index donné dans le vecteur simultané. Cette méthode est sécurisée par concurrence pour les opérations de lecture, et également lors de la croissance du vecteur, tant que vous avez vérifié que la valeur _Index est inférieure à la taille du vecteur simultané.

reference operator[](size_type _index);

const_reference operator[](size_type _index) const;

Paramètres

_Index
Index de l’élément à récupérer.

Valeur de retour

Référence à l’élément à l’index donné.

Notes

La version de operator [] celle-ci const retourne une référence non-référencée ne peut pas être utilisée simultanément pour écrire dans l’élément à partir de différents threads. Un objet de synchronisation différent doit être utilisé pour synchroniser les opérations de lecture et d’écriture simultanées dans le même élément de données.

Aucune limite case activée ing n’est effectuée pour s’assurer qu’il _Index s’agit d’un index valide dans le vecteur simultané.

push_back

Ajoute l’élément donné à la fin du vecteur simultané. Cette méthode est concurrency-safe.

iterator push_back(const_reference _Item);

iterator push_back(T&& _Item);

Paramètres

_Article
Valeur à ajouter.

Valeur de retour

Itérateur à l’élément ajouté.

rbegin

Retourne un itérateur de type reverse_iterator ou const_reverse_iterator au début du vecteur simultané. Cette méthode est concurrency-safe.

reverse_iterator rbegin();

const_reverse_iterator rbegin() const;

Valeur de retour

Itérateur de type reverse_iterator ou const_reverse_iterator au début du vecteur simultané.

rend

Retourne un itérateur de type reverse_iterator ou const_reverse_iterator à la fin du vecteur simultané. Cette méthode est concurrency-safe.

reverse_iterator rend();

const_reverse_iterator rend() const;

Valeur de retour

Itérateur de type reverse_iterator ou const_reverse_iterator à la fin du vecteur simultané.

reserve

Alloue suffisamment d’espace pour augmenter la taille _N du vecteur simultané sans avoir à allouer plus de mémoire ultérieurement. Cette méthode n’est pas sécurisée par concurrence.

void reserve(size_type _N);

Paramètres

_¡n
Nombre d’éléments à réserver de l’espace.

Notes

reserve n’est pas sécurisé par la concurrence. Vous devez vous assurer qu’aucun autre thread n’appelle des méthodes sur le vecteur simultané lorsque vous appelez cette méthode. La capacité du vecteur simultané après le retour de la méthode peut être supérieure à la réservation demandée.

resize

Modifie la taille du vecteur simultané par la taille demandée, la suppression ou l’ajout d’éléments si nécessaire. Cette méthode n’est pas sécurisée par concurrence.

void resize(
    size_type _N);

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

Paramètres

_¡n
Nouvelle taille du concurrent_vector.

val
Valeur des nouveaux éléments ajoutés au vecteur si la nouvelle taille est supérieure à la taille d’origine. Si la valeur est omise, les nouveaux objets sont affectés à la valeur par défaut de leur type.

Notes

Si la taille du conteneur est inférieure à la taille demandée, les éléments sont ajoutés au vecteur jusqu’à ce qu’il atteigne la taille demandée. Si la taille du conteneur est supérieure à la taille demandée, les éléments les plus proches de la fin du conteneur sont supprimés jusqu’à ce que le conteneur atteigne la taille _N. Si la taille actuelle du conteneur est égale à la taille demandée, aucune action n'est effectuée.

resize n’est pas sécurisé pour la concurrence. Vous devez vous assurer qu’aucun autre thread n’appelle des méthodes sur le vecteur simultané lorsque vous appelez cette méthode.

shrink_to_fit

Compacte la représentation interne du vecteur simultané pour réduire la fragmentation et optimiser l’utilisation de la mémoire. Cette méthode n’est pas sécurisée par concurrence.

void shrink_to_fit();

Notes

Cette méthode réalloue en interne des éléments de déplacement de mémoire, invalidant tous les itérateurs. shrink_to_fit n’est pas sécurisé par la concurrence. Vous devez vous assurer qu’aucun autre thread n’appelle des méthodes sur le vecteur simultané lorsque vous appelez cette fonction.

size

Retourne le nombre d’éléments dans le vecteur simultané. Cette méthode est concurrency-safe.

size_type size() const;

Valeur de retour

Nombre d’éléments dans cet concurrent_vector objet.

Notes

La taille retournée est garantie d’inclure tous les éléments ajoutés par des appels à la fonction push_back, ou des opérations de croissance terminées avant d’appeler cette méthode. Toutefois, il peut également inclure des éléments alloués mais toujours en cours de construction par des appels simultanés à l’une des méthodes de croissance.

swap

Échange le contenu de deux vecteurs simultanés. Cette méthode n’est pas sécurisée par concurrence.

void swap(concurrent_vector& _Vector);

Paramètres

_Vecteur
Objet avec lequel échanger le concurrent_vector contenu.

Voir aussi

accès concurrentiel Namespace
Conteneurs et objets parallèles