¿Se garantiza que los elementos std :: vector sean contiguos?

Mi pregunta es simple: ¿se garantiza que los elementos std :: vector sean contiguos? En orden, ¿puedo usar el puntero al primer elemento de un std :: vector como una matriz C?

Si mi memoria no me sirve bien, el estándar C ++ no ofrecía tal garantía. Sin embargo, los requisitos de std :: vector eran tales que era prácticamente imposible cumplirlos si los elementos no eran contiguos.

¿Alguien puede aclarar esto?

Ejemplo:

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

Esto se omitió del estándar C ++ 98 propiamente dicho, pero luego se agregó como parte de un TR. El próximo estándar C ++ 0x, por supuesto, lo incluirá como requisito.

Desde n2798 (borrador de C ++ 0x):

23.2.6 Vector de plantilla de clase [vector]

1 Un vector es un contenedor de secuencia que admite iteradores de acceso aleatorio. Además, admite operaciones de inserción y borrado de tiempo constante (amortizadas) al final; insertar y borrar en el medio toman un tiempo lineal. La administración del almacenamiento se maneja automáticamente, aunque se pueden dar sugerencias para mejorar la eficiencia. Los elementos de un vector se almacenan contiguamente, lo que significa que si v es un vector donde T es de algún tipo diferente a bool, entonces obedece a la identidad & v [n] == & v [0] + n para todo 0 <= n <v .Talla().

Como han señalado otras respuestas, se garantiza que el contenido de un vector sea continuo (excepto la rareza de bool).

El comentario que quería agregar es que si realiza una inserción o una eliminación en el vector, lo que podría hacer que el vector reasigne su memoria, entonces hará que todos sus punteros e iteradores guardados se invaliden.

De hecho, el estándar garantiza que a vectorsea ​​continuo en la memoria y que &a[0]se pueda pasar a una Cfunción que espera una matriz.

La excepción a esta regla es vector<bool>que solo usa un bit por bool, por lo tanto, aunque tiene memoria continua, no se puede usar como bool*(esto se considera una optimización falsa y un error).

Por cierto, ¿por qué no usas iteradores? Para eso son.

Como ya han dicho otros, vector utiliza internamente una matriz contigua de objetos. Los punteros en esa matriz deben tratarse como inválidos siempre que cualquier función miembro no constante se llame IIRC.

¡¡Como sea, hay una excepción!!

vector<bool>tiene una implementación especializada diseñada para ahorrar espacio, de modo que cada bool solo usa un bit. La matriz subyacente no es una matriz contigua de bool y la aritmética de matriz vector<bool>no funciona comovector<T> haría.

(Supongo que también es posible que esto sea cierto para cualquier especialización de vector, ya que siempre podemos implementar una nueva. Sin embargo, std::vector<bool>es la única especialización estándar en la que la aritmética de puntero simple no funcionará).

Encontré este hilo porque tengo un caso de uso en el que los vectores que usan memoria contigua son una ventaja.

Estoy aprendiendo a usar objetos de búfer de vértice en OpenGL. Creé una clase contenedora para contener la lógica del búfer, por lo que todo lo que necesito hacer es pasar una matriz de flotantes y algunos valores de configuración para crear el búfer. Quiero poder generar un búfer a partir de una función basada en la entrada del usuario, por lo que no se conoce la longitud en el momento de la compilación. Hacer algo como esto sería la solución más sencilla:

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

Ahora puedo pasar los flotantes del vector como una matriz a las funciones relacionadas con el búfer de OpenGL. Esto también elimina la necesidad de sizeof para determinar la longitud de la matriz.

Esto es mucho mejor que asignar una matriz enorme para almacenar los flotadores y esperar que sea lo suficientemente grande, o hacer mi propia matriz dinámica con almacenamiento contiguo.

cplusplus.com:

Los contenedores vectoriales se implementan como matrices dinámicas; Al igual que los arreglos regulares, los contenedores vectoriales tienen sus elementos almacenados en ubicaciones de almacenamiento contiguas, lo que significa que se puede acceder a sus elementos no solo usando iteradores sino también usando compensaciones en punteros regulares a elementos.

Sí, se garantiza que los elementos de un std :: vector son contiguos.