Gli elementi std :: vector sono garantiti per essere contigui?

La mia domanda è semplice: gli elementi std :: vector sono garantiti per essere contigui? In ordine di parola, posso usare il puntatore al primo elemento di uno std :: vector come un C-array?

Se la mia memoria mi serve bene, lo standard C ++ non offre tale garanzia. Tuttavia, i requisiti std :: vector erano tali che era virtualmente impossibile soddisfarli se gli elementi non erano contigui.

Qualcuno può chiarire questo?

Esempio:

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'
    }
}

Questo era mancato dallo standard C ++ 98 vero e proprio, ma successivamente aggiunto come parte di un TR. Il prossimo standard C ++ 0x lo conterrà ovviamente come requisito.

Da n2798 (bozza di C ++ 0x):

23.2.6 Modello di classe vettore [vettore]

1 Un vettore è un contenitore di sequenze che supporta iteratori ad accesso casuale. Inoltre, supporta operazioni di inserimento e cancellazione a tempo costante (ammortizzato) alla fine; inserire e cancellare nel mezzo richiede tempo lineare. La gestione dello storage viene gestita automaticamente, sebbene sia possibile fornire suggerimenti per migliorare l'efficienza. Gli elementi di un vettore sono memorizzati in modo contiguo, il che significa che se v è un vettore dove T è un tipo diverso da bool, allora obbedisce all'identità & v [n] == & v [0] + n per tutti 0 <= n <v .taglia().

Come altre risposte hanno sottolineato, il contenuto di un vettore è garantito per essere continuo (eccetto la stranezza di bool).

Il commento che volevo aggiungere è che se fai un inserimento o una cancellazione sul vettore, che potrebbe causare il vettore a riallocare la sua memoria, allora tutti i tuoi puntatori e iteratori salvati verranno invalidati.

Lo standard infatti garantisce che a vectorsia continuo in memoria e che &a[0]possa essere passato a una Cfunzione che si aspetta un array.

L'eccezione a questa regola è vector<bool>che utilizza solo un bit per boolquindi, sebbene abbia una memoria continua, non può essere utilizzata come un bool*(questo è ampiamente considerato come una falsa ottimizzazione e un errore).

BTW, perché non usi gli iteratori? Ecco a cosa servono.

Come altri hanno già detto, vector utilizza internamente un array contiguo di oggetti. I puntatori in quell'array dovrebbero essere considerati non validi ogni volta che una funzione membro non const viene chiamata IIRC.

Tuttavia, c'è un'eccezione !!

vector<bool>ha un'implementazione specializzata progettata per risparmiare spazio, in modo che ogni bool utilizzi solo un bit. L'array sottostante non è un array contiguo di bool e l'aritmetica dell'array su vector<bool>non funziona come vector<T>farebbe.

(Suppongo che sia anche possibile che questo possa essere vero per qualsiasi specializzazione del vettore, dal momento che possiamo sempre implementarne una nuova. Tuttavia, std::vector<bool>è l'unica, ehm, specializzazione standard su cui la semplice aritmetica dei puntatori non funzionerà.)

Ho trovato questo thread perché ho un caso d'uso in cui i vettori che utilizzano la memoria contigua sono un vantaggio.

Sto imparando a usare gli oggetti del buffer dei vertici in OpenGL. Ho creato una classe wrapper per contenere la logica del buffer, quindi tutto ciò che devo fare è passare un array di float e alcuni valori di configurazione per creare il buffer. Voglio essere in grado di generare un buffer da una funzione basata sull'input dell'utente, quindi la lunghezza non è nota in fase di compilazione. Fare qualcosa del genere sarebbe la soluzione più semplice:

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

Ora posso passare i float del vettore come array alle funzioni relative al buffer di OpenGL. Ciò elimina anche la necessità di sizeof per determinare la lunghezza dell'array.

Questo è molto meglio che allocare un array enorme per memorizzare i float e sperare di averlo reso abbastanza grande, o creare il mio array dinamico con memoria contigua.

cplusplus.com:

I contenitori vettoriali vengono implementati come array dinamici; Proprio come gli array normali, i contenitori vettoriali hanno i loro elementi memorizzati in posizioni di archiviazione contigue, il che significa che è possibile accedere ai loro elementi non solo utilizzando iteratori ma anche utilizzando offset su puntatori regolari agli elementi.

Sì, è garantito che gli elementi di uno std :: vector siano contigui.