Os elementos std :: vector são garantidamente contíguos?

Minha pergunta é simples: os elementos std :: vector são garantidamente contíguos? Em resumo, posso usar o ponteiro para o primeiro elemento de um std :: vector como um C-array?

Se não me falha a memória, o padrão C ++ não oferecia tal garantia. No entanto, os requisitos std :: vector eram tais que era virtualmente impossível atendê-los se os elementos não fossem contíguos.

Alguém pode esclarecer isso?

Exemplo:

std::vector<int> values;
// ... fill up values

if( !values.empty() )
{
    int *array = &values[0];
    for( int i = 0; i < values.size(); ++i )
    {
        int v = array[i];
        // do something with 'v'
    }
}

Isso foi omitido no padrão C ++ 98 propriamente dito, mas posteriormente adicionado como parte de um TR. O próximo padrão C ++ 0x irá obviamente conter isso como um requisito.

De n2798 (rascunho de C ++ 0x):

23.2.6 Vetor de modelo de classe [vetor]

1 Um vetor é um contêiner de sequência que suporta iteradores de acesso aleatório. Além disso, ele suporta operações de inserção e exclusão de tempo constante (amortizado) no final; inserir e apagar no meio leva tempo linear. O gerenciamento de armazenamento é feito automaticamente, embora possam ser fornecidas dicas para melhorar a eficiência. Os elementos de um vetor são armazenados contiguamente, o que significa que se v é um vetor onde T é algum tipo diferente de bool, então ele obedece à identidade & v [n] == & v [0] + n para todos os 0 <= n <v .Tamanho().

Como outras respostas indicaram, o conteúdo de um vetor é garantidamente contínuo (exceto pela estranheza de bool).

O comentário que eu queria adicionar é que se você fizer uma inserção ou exclusão no vetor, o que poderia fazer com que o vetor realocasse sua memória, você fará com que todos os seus ponteiros e iteradores salvos sejam invalidados.

O padrão de fato garante que a vectorseja contínuo na memória e que &a[0]possa ser passado para uma Cfunção que espera um array.

A exceção a esta regra é vector<bool>que usa apenas um bit por, boolportanto, embora tenha memória contínua, ela não pode ser usada como um bool*(isso é amplamente considerado uma otimização falsa e um erro).

BTW, por que você não usa iteradores? É para isso que servem.

Como outros já disseram, vector internamente usa uma matriz contígua de objetos. Os ponteiros para essa matriz devem ser tratados como inválidos sempre que qualquer função de membro não const for chamada de IIRC.

Contudo, há uma exceção!!

vector<bool>possui uma implementação especializada projetada para economizar espaço, de forma que cada bool use apenas um bit. A matriz subjacente não é uma matriz contígua de bool e a aritmética da matriz vector<bool>não funciona como vector<T>faria.

(Suponho que também seja possível que isso seja verdade para qualquer especialização de vetor, uma vez que sempre podemos implementar uma nova. No entanto, std::vector<bool>é a única, err, especialização padrão em que a aritmética de ponteiro simples não funciona.)

Eu encontrei esse segmento porque tenho um caso de uso em que vetores que usam memória contígua são uma vantagem.

Estou aprendendo a usar objetos de buffer de vértice em OpenGL. Eu criei uma classe de wrapper para conter a lógica do buffer, então tudo que preciso fazer é passar uma matriz de floats e alguns valores de configuração para criar o buffer. Quero ser capaz de gerar um buffer a partir de uma função com base na entrada do usuário, portanto, o comprimento não é conhecido no momento da compilação. Fazer algo assim seria a solução mais fácil:

void generate(std::vector<float> v)
{
  float f = generate_next_float();
  v.push_back(f);
}

Agora posso passar os flutuadores do vetor como um array para as funções relacionadas ao buffer do OpenGL. Isso também elimina a necessidade de sizeof para determinar o comprimento da matriz.

Isso é muito melhor do que alocar um grande array para armazenar os floats e esperar que eu o torne grande o suficiente, ou fazer meu próprio array dinâmico com armazenamento contíguo.

cplusplus.com:

Os contêineres de vetor são implementados como matrizes dinâmicas; Assim como os arrays regulares, os contêineres de vetor têm seus elementos armazenados em locais de armazenamento contíguos, o que significa que seus elementos podem ser acessados ​​não apenas usando iteradores, mas também usando offsets em ponteiros regulares para os elementos.

Sim, os elementos de um std :: vector são garantidamente contíguos.