concurrent_vector Classe

A concurrent_vector classe é uma classe de contêiner de sequência que permite acesso aleatório a qualquer elemento. Permite operações de acréscimo seguro em concorrência, acesso a elementos, acesso a iteradores e percurso de iteradores. Aqui, segurança de concorrência significa que os ponteiros ou iteradores são sempre válidos. Não é uma garantia da inicialização de elementos ou de uma ordem de percorrimento 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 encapsula detalhes sobre a alocação e 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

Observações

Para obter informações detalhadas sobre a classe concurrent_vector, consulte Parallel Containers and Objects.

Hierarquia de herança

_Concurrent_vector_base_v4

_Allocator_base

concurrent_vector

Requerimentos

Cabeçalho: concurrent_vector.h

Namespace: simultaneidade

atribuir

Apaga os elementos do vetor simultâneo e atribui a ele ou _N cópias de _Item, ou valores especificados pelo intervalo do iterador [ _Begin, _End). Este 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 para o vetor concorrente.

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

_Begin
Um iterador para o primeiro elemento do intervalo de origem.

_End
Um iterador para um além do último elemento do intervalo fonte.

Observações

assign não é seguro para simultaneidade. Você deve garantir que nenhum outro thread esteja invocando métodos no vetor simultâneo quando você chamar esse método.

em

Fornece acesso ao elemento no índice dado no vetor simultâneo. Esse método é seguro para simultaneidade para operações de leitura e também durante o crescimento do vetor, desde que você tenha garantido que o valor _Index seja menor do que o tamanho do vetor simultâneo.

reference at(size_type _Index);

const_reference at(size_type _Index) const;

Parâmetros

_Index
O índice do elemento a ser recuperado.

Valor de retorno

Uma referência ao item no índice fornecido.

Observações

A versão da função at que retorna uma referência que não é const não pode ser usada para efetuar escrita simultaneamente no elemento 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.

O método lança out_of_range se _Index é maior ou igual ao tamanho do vetor simultâneo e range_error se o índice é para uma porção quebrada do vetor. Para obter detalhes sobre como um vetor pode ser quebrado, consulte Contêineres e objetos paralelos.

Voltar

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

reference back();

const_reference back() const;

Valor de retorno

Uma referência ou uma const referência ao último elemento no vetor concorrente.

começar

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

iterator begin();

const_iterator begin() const;

Valor de retorno

Um iterador do 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 crescer sem ter que alocar mais memória. Este método é seguro para simultaneidade.

size_type capacity() const;

Valor de retorno

O tamanho máximo para o qual o vetor simultâneo pode crescer sem ter que alocar mais memória.

Observações

Ao contrário de uma biblioteca vectorpadrão C++, um concurrent_vector objeto não move elementos existentes se alocar mais memória.

cbegin

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

const_iterator cbegin() const;

Valor de retorno

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

Curva

Retorna um iterador do tipo const_iterator para o final do vetor simultâneo. Este método é seguro para simultaneidade.

const_iterator cend() const;

Valor de retorno

Um iterador do tipo const_iterator até o final do vetor simultâneo.

desmarcar

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

void clear();

Observações

clear não é seguro para simultaneidade. Você deve garantir que nenhum outro thread esteja invocando métodos no vetor simultâneo quando você chamar esse método. clear não libera matrizes internas. Para liberar 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.

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

_N
A capacidade inicial do concurrent_vector objeto.

_Item
O valor dos elementos no objeto construído.

_Begin
Posição do primeiro elemento na gama de elementos a copiar.

_End
Posição do primeiro elemento para além da gama de elementos a copiar.

Observações

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

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

O segundo e terceiro construtores especificam uma cópia do vetor _Vector concorrente.

O quarto construtor especifica um movimento do vetor _Vectorsimultâneo .

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

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

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

~concurrent_vetor

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

~concurrent_vector();

crbegin

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

const_reverse_iterator crbegin() const;

Valor de retorno

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

Crend

Retorna um iterador do tipo const_reverse_iterator para o final do vetor simultâneo. Este método é seguro para simultaneidade.

const_reverse_iterator crend() const;

Valor de retorno

Um iterador do tipo const_reverse_iterator até o final do vetor simultâneo.

vazio

Testa se o vetor simultâneo está vazio no momento em que este método é chamado. Este 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, false caso contrário.

fim

Retorna um iterador do tipo iterator ou const_iterator para o final do vetor simultâneo. Este 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 simultâneo.

frente

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

reference front();

const_reference front() const;

Valor de retorno

Uma referência ou uma const referência ao primeiro elemento no vetor concorrente.

get_allocator

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

allocator_type get_allocator() const;

Valor de retorno

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

grow_by

Cresce este vetor simultâneo por _Delta elementos. Este 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 anexados ao objeto.

_Item
O valor com o qual inicializar os novos elementos.

Valor de retorno

Um iterador para o primeiro item adicionado.

Observações

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

crescer_para_pelo_menos

Cresce este vetor simultâneo até que ele tenha pelo menos _N elementos. Este método é seguro para simultaneidade.

iterator grow_to_at_least(size_type _N);

Parâmetros

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

Valor de retorno

Um iterador que aponta para o início da sequência anexada ou para o elemento no índice _N se nenhum elemento foi acrescentado.

tamanho_máximo

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

size_type max_size() const;

Valor de retorno

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

operador=

Atribui ao objeto concurrent_vector o conteúdo de outro. Este 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.

_Vector
O objeto de origem concurrent_vector.

Valor de retorno

Uma referência a este objeto concurrent_vector.

operador[]

Fornece acesso ao elemento no índice dado no vetor simultâneo. Esse método é confiável em concorrência para operações de leitura e também durante o crescimento do vetor, desde que se tenha assegurado que o valor _Index é menor do que o tamanho do vetor concorrente.

reference operator[](size_type _index);

const_reference operator[](size_type _index) const;

Parâmetros

_Index
O índice do elemento a ser recuperado.

Valor de retorno

Uma referência ao item no índice fornecido.

Observações

A versão de operator [] que retorna uma referência não-const não pode ser usada para escrever no elemento simultaneamente 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.

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

push_back

Acrescenta o item dado ao final do vetor simultâneo. Este 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 para o item anexado.

recomeçar

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

reverse_iterator rbegin();

const_reverse_iterator rbegin() const;

Valor de retorno

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

renderizar

Retorna um iterador do tipo reverse_iterator ou const_reverse_iterator para o final do vetor simultâneo. Este 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 simultâneo.

Reserva

Aloca espaço suficiente para aumentar o vetor simultâneo para o tamanho _N sem ter que alocar mais memória mais tarde. Este método não é seguro para simultaneidade.

void reserve(size_type _N);

Parâmetros

_N
O número de elementos para os quais reservar espaço.

Observações

reserve não é seguro para simultaneidade. Você deve garantir que nenhum outro thread esteja invocando métodos no vetor simultâneo quando você 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. Este 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_vetor.

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

Observações

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

resize não é seguro para simultaneidade. Você deve garantir que nenhum outro thread esteja invocando métodos no vetor simultâneo quando você chamar esse método.

shrink_to_fit

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

void shrink_to_fit();

Observações

Esse método irá realocar internamente os elementos de movimentação de memória, invalidando todos os iteradores. shrink_to_fit não é seguro para simultaneidade. Você deve garantir que nenhum outro thread esteja invocando métodos no vetor simultâneo quando você chamar essa função.

tamanho

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

size_type size() const;

Valor de retorno

O número de elementos neste concurrent_vector objeto.

Observações

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

permuta

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

void swap(concurrent_vector& _Vector);

Parâmetros

_Vector
O objeto concurrent_vector com o qual trocar os conteúdos.

Ver também

concorrência Namespace
Contêineres e objetos paralelos