Classe concurrent_vector

A classe concurrent_vector é uma classe de contêiner de sequência que permite acesso aleatório a qualquer elemento. Ela habilita o acréscimo concurrency-safe, o acesso ao elemento, o acesso ao iterador e as operações de passagem do iterador. Aqui, concurrency-safe significa que os ponteiros ou iteradores são sempre válidos. Não é uma garantia de inicialização do elemento ou de uma ordem de passagem específica.

Sintaxe

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

Parâmetros

T
O tipo de dados dos elementos a serem armazenados no vetor.

_Ax
O tipo que representa o objeto alocador armazenado que contém detalhes sobre a alocação e a desalocação de memória para o vetor concorrente. Esse argumento é opcional e o valor padrão é allocator<T>.

Membros

Typedefs públicos

Construtores públicos

Métodos públicos

Operadores públicos

Comentários

Para obter informações detalhadas sobre a classe concurrent_vector, confira Contêineres e objetos paralelos.

Hierarquia de herança

_Concurrent_vector_base_v4

_Allocator_base

concurrent_vector

Requisitos

Cabeçalho: concurrent_vector.h

Namespace: simultaneidade

atribuir

Apaga os elementos do vetor concorrente e atribui a ele ou _N cópias de _Item, ou os valores especificados pelo intervalo de iteradores [_Begin, _End). Esse método não é seguro para simultaneidade.

void assign(
    size_type _N,
    const_reference _Item);

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

Parâmetros

_InputIterator
O tipo do iterador especificado.

_N
O número de itens para copiar no vetor concorrente.

_Item
Referência a um valor usado para preencher o vetor simultâneo.

_Começar
Um iterador para o primeiro elemento do intervalo de origem.

_Fim
Um iterador para um elemento após o último no intervalo de origem.

Comentários

assign não é seguro para concorrência. Você deve garantir que outros threads não invoquem os métodos no vetor simultâneo, ao chamar esse método.

em

Fornece acesso ao elemento no índice fornecido no vetor concorrente. Esse método é seguro para concorrência em operações de leitura e também ao expandir o vetor, desde que você tenha garantido que o valor _Index seja menor que o tamanho do vetor concorrente.

reference at(size_type _Index);

const_reference at(size_type _Index) const;

Parâmetros

_Índice
O índice do elemento a ser recuperado.

Valor de retorno

Uma referência ao item no índice fornecido.

Comentários

Não é possível usar a versão da função at que retorna uma referência não const para gravar simultaneamente no elemento a partir de threads diferentes. Um objeto de sincronização diferente deve ser usado para sincronizar operações simultâneas de leitura e gravação com o mesmo elemento de dados.

O método gera out_of_range, se _Index for maior que ou igual ao tamanho do vetor simultâneo, e range_error, se o índice for para uma parte interrompida do vetor. Para obter detalhes sobre como um vetor pode ser interrompido, confira Contêineres e Objetos Paralelos.

voltar

Retorna uma referência ou uma referência const ao último elemento no vetor simultâneo. Se o vetor simultâneo estiver vazio, o valor retornado será indefinido. Esse método é seguro para simultaneidade.

reference back();

const_reference back() const;

Valor de retorno

Uma referência ou uma referência const ao último elemento no vetor simultâneo.

começar

Retorna um iterador de tipo iterator ou const_iterator para o início do vetor simultâneo. Esse método é seguro para simultaneidade.

iterator begin();

const_iterator begin() const;

Valor de retorno

Um iterador de tipo iterator ou const_iterator para o início do vetor concorrente.

capacidade

Retorna o tamanho máximo para o qual o vetor simultâneo pode aumentar, sem precisar alocar mais memória. Esse método é seguro para simultaneidade.

size_type capacity() const;

Valor de retorno

O tamanho máximo para o qual o vetor simultâneo pode aumentar, sem precisar alocar mais memória.

Comentários

Ao contrário de uma Biblioteca Standard C++ vector, um objeto concurrent_vector não moverá os elementos existentes, se alocar mais memória.

cbegin

Retorna um iterador de tipo const_iterator para o início do vetor simultâneo. Esse método é seguro para simultaneidade.

const_iterator cbegin() const;

Valor de retorno

Um iterador de tipo const_iterator para o início do vetor simultâneo.

cend

Retorna um iterador de tipo const_iterator para o final do vetor concorrente. Esse método é seguro para simultaneidade.

const_iterator cend() const;

Valor de retorno

Um iterador de tipo const_iterator para o final do vetor simultâneo.

desmarcar

Apaga todos os elementos no vetor simultâneo. Esse método não é seguro para simultaneidade.

void clear();

Comentários

clear não é seguro para concorrência. Você deve garantir que outros threads não invoquem os métodos no vetor simultâneo, ao chamar esse método. clear não libera as matrizes internas. Para liberar as matrizes internas, chame a função shrink_to_fit após clear.

concurrent_vector

Constrói um vetor simultâneo.

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

Parâmetros

M
O tipo de alocador do vetor de origem.

_InputIterator
O tipo do iterador de entrada.

_Al
A classe de alocador a ser usada com esse objeto.

_Vetor
O objeto concurrent_vector de origem do qual copiar ou mover elementos.

_N
A capacidade inicial do objeto concurrent_vector.

_Item
O valor dos elementos no objeto construído.

_Começar
A posição do primeiro elemento no intervalo de elementos a ser copiado.

_Fim
A posição do primeiro elemento além do conjunto de elementos que será copiado.

Comentários

Todos os construtores armazenam um objeto alocador _Al e iniciam o vetor.

O primeiro construtor especifica um vetor inicial vazio e especifica explicitamente o tipo de alocador. a ser usado.

O segundo e o terceiro construtores especificam uma cópia do vetor simultâneo _Vector.

O quarto construtor especifica uma movimentação do vetor simultâneo _Vector.

O quinto construtor especifica uma repetição de um número especificado (_N) de elementos do valor padrão para a classe T.

O sexto construtor especifica uma repetição dos (_N) elementos de valor _Item.

O último construtor especifica valores fornecidos pelo intervalo do iterador (_Begin, _End).

~ concurrent_vector

Apaga todos os elementos e destrói esse vetor simultâneo.

~concurrent_vector();

crbegin

Retorna um iterador de tipo const_reverse_iterator para o início do vetor simultâneo. Esse método é seguro para simultaneidade.

const_reverse_iterator crbegin() const;

Valor de retorno

Um iterador de tipo const_reverse_iterator para o início do vetor simultâneo.

crend

Retorna um iterador de tipo const_reverse_iterator para o final do vetor concorrente. Esse método é seguro para simultaneidade.

const_reverse_iterator crend() const;

Valor de retorno

Um iterador de tipo const_reverse_iterator ao final do vetor concorrente.

vazio

Testa se o vetor simultâneo está vazio no momento em que esse método é chamado. Esse método é seguro para simultaneidade.

bool empty() const;

Valor de retorno

true, se o vetor estava vazio no momento em que a função foi chamada. Caso contrário, false.

término

Retorna um iterador de tipo iterator ou const_iterator para o final do vetor simultâneo. Esse método é seguro para simultaneidade.

iterator end();

const_iterator end() const;

Valor de retorno

Um iterador do tipo iterator ou const_iterator até o final do vetor concorrente.

frente

Retorna uma referência ou uma referência const ao primeiro elemento no vetor simultâneo. Se o vetor simultâneo estiver vazio, o valor retornado será indefinido. Esse método é seguro para simultaneidade.

reference front();

const_reference front() const;

Valor de retorno

Uma referência ou uma referência const ao primeiro elemento no vetor simultâneo.

get_allocator

Retorna uma cópia do alocador usado para construir o vetor simultâneo. Esse método é seguro para simultaneidade.

allocator_type get_allocator() const;

Valor de retorno

Uma cópia do alocador usado para construir o objeto concurrent_vector.

grow_by

Cresce este vetor simultâneo por _Delta elementos. Esse método é seguro para simultaneidade.

iterator grow_by(
    size_type _Delta);

iterator grow_by(
    size_type _Delta,
    const_reference _Item);

Parâmetros

_Delta
O número de elementos a serem acrescentados ao objeto.

_Item
O valor com o qual os novos elementos devem ser inicializados.

Valor de retorno

Um iterador para o primeiro item acrescentado.

Comentários

Se _Item não for especificado, os novos elementos serão construídos por padrão.

crescer_para_no_mínimo

Aumenta esse vetor simultâneo até que ele tenha pelo menos _N elementos. Esse método é seguro para simultaneidade.

iterator grow_to_at_least(size_type _N);

Parâmetros

_N
O novo tamanho mínimo para o objeto concurrent_vector.

Valor de retorno

Um iterador que aponta para o início da sequência acrescentada ou para o elemento no índice _N, se nenhum elemento tiver sido acrescentado.

max_size

Retorna o número máximo de elementos que o vetor simultâneo pode conter. Esse método é seguro para simultaneidade.

size_type max_size() const;

Valor de retorno

O número máximo de elementos que o objeto concurrent_vector pode conter.

operator=

Atribui o conteúdo de outro objeto concurrent_vector a este. Esse método não é seguro para simultaneidade.

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

Parâmetros

M
O tipo de alocador do vetor de origem.

_Vetor
O objeto de origem concurrent_vector .

Valor de retorno

Uma referência a esse objeto concurrent_vector.

operador []

Fornece acesso ao elemento no índice fornecido no vetor concorrente. Esse método é seguro para operações de leitura concorrentes e também ao aumentar o vetor, desde que você tenha garantido que o valor _Index seja menor que o tamanho do vetor concorrente.

reference operator[](size_type _index);

const_reference operator[](size_type _index) const;

Parâmetros

_Índice
O índice do elemento a ser recuperado.

Valor de retorno

Uma referência ao item no índice fornecido.

Comentários

Não é possível usar a versão de operator [] que retorna uma referência não const para gravar no elemento simultaneamente a partir de diferentes threads. Um objeto de sincronização diferente deve ser usado para sincronizar operações simultâneas de leitura e gravação com o mesmo elemento de dados.

Nenhuma verificação de limites é executada para garantir que _Index seja um índice válido no vetor simultâneo.

push_back

Acrescenta o item determinado ao final do vetor concorrente. Esse método é seguro para simultaneidade.

iterator push_back(const_reference _Item);

iterator push_back(T&& _Item);

Parâmetros

_Item
O valor a ser acrescentado.

Valor de retorno

Um iterador associado ao item adicionado.

rbegin

Retorna um iterador de tipo reverse_iterator ou const_reverse_iterator para o início do vetor simultâneo. Esse método é seguro para simultaneidade.

reverse_iterator rbegin();

const_reverse_iterator rbegin() const;

Valor de retorno

Um iterador de tipo reverse_iterator ou const_reverse_iterator para o início do vetor concorrente.

rasgar

Retorna um iterador de tipo reverse_iterator ou const_reverse_iterator para o final do vetor simultâneo. Esse método é seguro para simultaneidade.

reverse_iterator rend();

const_reverse_iterator rend() const;

Valor de retorno

Um iterador do tipo reverse_iterator ou const_reverse_iterator até o final do vetor concorrente.

reservar

Aloca espaço suficiente para aumentar o vetor simultâneo para o tamanho _N, sem precisar alocar mais memória posteriormente. Esse método não é seguro para simultaneidade.

void reserve(size_type _N);

Parâmetros

_N
O número de elementos para os quais o espaço deve ser reservado.

Comentários

reserve não é seguro para concorrência. Você deve garantir que outros threads não invoquem os métodos no vetor simultâneo, ao chamar esse método. A capacidade do vetor simultâneo após o retorno do método pode ser maior do que a reserva solicitada.

redimensionar

Altera o tamanho do vetor simultâneo para o tamanho solicitado, excluindo ou adicionando elementos, conforme necessário. Esse método não é seguro para simultaneidade.

void resize(
    size_type _N);

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

Parâmetros

_N
O novo tamanho do concurrent_vector.

val
O valor de novos elementos adicionados ao vetor, caso o novo tamanho seja maior que o tamanho original. Se o valor for omitido, os novos objetos receberão o valor padrão para o tipo.

Comentários

Se o tamanho do contêiner for menor que o tamanho solicitado, serão adicionados os elementos ao vetor até que ele atinja o tamanho solicitado. Se o tamanho do contêiner for maior que o tamanho solicitado, os elementos mais próximos do final do contêiner são excluídos até o contêiner chegar ao tamanho _N. Se o tamanho atual do contêiner for igual ao tamanho solicitado, nenhuma ação será realizada.

resize não é seguro para concorrência. Você deve garantir que outros threads não invoquem os métodos no vetor simultâneo, ao chamar esse método.

reduzir_para_ajustar

Compacta a representação interna do vetor simultâneo para reduzir a fragmentação e otimizar o uso da memória. Esse método não é seguro para simultaneidade.

void shrink_to_fit();

Comentários

Esse método re-alocará memória internamente e moverá elementos, invalidando todos os iteradores. shrink_to_fit não é seguro para concorrência. Você deve garantir que outros threads não invoquem os métodos no vetor simultâneo, ao chamar essa função.

tamanho

Retorna o número de elementos no vetor concorrente. Esse método é seguro para simultaneidade.

size_type size() const;

Valor de retorno

O número de elementos no objeto concurrent_vector.

Comentários

O tamanho retornado é garantido para incluir todos os elementos acrescentados por chamadas à função push_back ou as operações de crescimento que foram concluídas antes de invocar esse método. No entanto, também pode incluir elementos alocados, mas ainda em construção por chamadas simultâneas a qualquer um dos métodos de crescimento.

trocar

Troca o conteúdo de dois vetores simultâneos. Esse método não é seguro para simultaneidade.

void swap(concurrent_vector& _Vector);

Parâmetros

_Vetor
O objeto concurrent_vector com o qual trocar conteúdo.

Confira também

Namespace de concorrência
Contêineres e objetos em paralelo