vector redimensionamento - maneira portátil para detectar

Question

Eu tenho um vetor que eu sou o carregamento com uma quantidade conhecimento de elementos (N).

O processamento cria dinamicamente elementos novos, os quais são anexas ao vector.

Estou esperando cerca de 2 * N elementos adicionais a serem criados, então eu redimensionar o vetor de 3 * N.

Se os elementos adicionais exceder isso, eu gostaria de um programa de aborto, em vez de uma expansão dinâmica do vetor.

Existe uma maneira de detectar que, que é portátil entre AIX / Tru64 / Linux?

Answer 1

Detectar o quê? Se o vector será redimensionada? Se foi?

A única maneira real para conseguir isso é para fornecer verificação funcionalidade ou em um alocador customizado ou uma função que adiciona elementos ao vetor.

exemplo

template<class T> 
void add_element(std::vector<T>& container, T const& v)
{
  if (container.capacity()+1 >= 3*N)
  {
    // terminate/exception/whatever
  }

 container.push_back(v);
}

Answer 2

Por que você está usando um vetor? O ponto de todo o vector é expandir dinamicamente quando necessário.

Em vez de fazer uma classe de delegar ao vetor, basta fazer uma classe de delegar a uma matriz simples. Ter o seu push_back verificar o tamanho e abortar quando necessário.

Answer 3

Crie a sua própria classe que irá delegar ao vetor. E tamanho verificar em seu próprio push_back.

Answer 4

Se você sabe o tamanho em tempo de compilação, talvez usando um std :: tr1 :: array (ou boost :: variedade ) seria uma melhor escolha. Ele mantém um tamanho e verificação de acesso fixo como std :: vector.

Se, contudo, você sabe que só em tempo de execução, como disse outros aqui, você deve encapsular seu vetor em uma classe com funções específicas que irá verificar as condições que você quer (via afirmações, por exemplo).

Nesta última abordagem, gostaria de sugerir, se você pode saber o tamanho máximo para a criação do vetor, a reserva (std :: vector :: reserva ()) o tamanho máximo do vetor em seu construtor da classe encapsular (ou função de inicialização). Dessa forma, não haverá mais manipulações memória pelo próprio vector (somente se os elementos do vetor construtor / destruidor fazer tais manipulações). Em seguida, adicionando uma simples afirmação de que verifica se a capacidade do vetor (std :: vector :: capacidade ()) nunca mudou no início e no final de todas as funções da sua classe irá ajudá-lo a se certificar de que sua memória não se movem.

Por exemplo (assumindo DATA_MAX_SIZE é um padrão tamanho máximo em algum lugar definido):

template< typename MyType >
class MyData
{
public:
    MyData( unsigned long max_size = DATA_MAX_SIZE )
        : m_max_size( max_size )
        { m_data.reserve( m_max_size ); }

    void add( const MyType& value ) { check_capacity(); m_data.push_back( value ); check_capacity(); }



private:

    std::vector< MyType > m_data;
    const unsigned long m_max_size;

    void check_capacity() { if( m_data.capacity() != m_max_size ) throw Exception("Useful error message here!" ); }

};

Ou algo assim ...

Answer 5

classes std usar um alocador chamado sempre que você inserir um elemento. Você pode escrever um novo alocador herdando da std :: alocator, e adicionar todos os tipos de cheques / traços que você precisa.

(eu fiz isso antes, mas ele me levou um tempo para fazer o código de trabalho.)