Usando operator [] en empty std :: vector

Question

Hace un tiempo me dijeron que era un lugar común para usar std :: vector como una matriz dinámica segura de excepción en C++ en lugar de asignar matrices sin formato ... por ejemplo

{ 
    std::vector<char> scoped_array (size); 
    char* pointer = &scoped_array[0]; 

    //do work 

} // exception safe deallocation 

he utilizado esta convención varias veces sin problemas, sin embargo, recientemente portado algo de código para Win32 VisualStudio2010 (antes era sólo en MacOS/Linux) y mis pruebas unitarias están rompiendo (stdlib emite una afirmar) cuando el tamaño del vector es cero.

Entiendo que escribir en una matriz de este tipo sería un problema, pero esta suposición rompe esta solución como un reemplazo de los punteros sin formato. Considere las siguientes funciones con n = 0

void foo (int n) { 
    char* raw_array = new char[n]; 
    char* pointer = raw_array; 
    file.read (pointer , n); 
    for (int i = 0; i < n; ++i) { 
     //do something 
    } 
    delete[] raw_array; 
} 

Si bien podría decirse redundante, el código anterior es perfectamente legal (creo), mientras que el código de abajo va a lanzar una afirmación en VisualStudio2010

void foo (int n) { 
    std::vector<char> scoped_array (n); 
    char* pointer = &scoped_array[0]; 
    file.read (pointer , n); 
    for (int i = 0; i < n; ++i) { 
    //do something 
    } 
} 

Era Estoy usando un comportamiento indefinido todo el tiempo? Yo tenía la impresión de operador [] hizo ninguna comprobación de errores, y esto era un uso válido de std :: vector <>. ¿Alquien más se ha encontrado con este problema?

--edit: Gracias por todas las respuestas útiles, en respuesta a la gente diciendo que es un comportamiento indefinido. ¿Hay alguna forma de reemplazar la asignación de matrices sin formato que se encuentra arriba con n = 0?

Si bien decir que la comprobación de n = 0 como caso excepcional se resolverá el problema (lo hará). Hay muchos patrones que no se necesita caso especial (como el ejemplo puntero del crudo por encima) así que tal vez utilizando algo más que std :: vector <> serían necesarios?

Answer 1

Ver LWG issue 464. Este es un problema conocido. C++ 0x (implementado parcialmente por MSVC 2010) lo resuelve agregando un miembro .data().

Answer 2

MVS no cubre la comprobación en operator[] incluso en las versiones de lanzamiento. No sé si cumple con las normas. (De hecho, encontré depurar código en su aplicación que hizo su ruptura implementación del código correcto). Sin embargo, hay un interruptor para deshabilitarlo.

Answer 3

Si desea obtener un comportamiento más limpio en este escenario, puede reemplazar el uso de a[0] con el uso a.at(0), que arrojará si el índice no es válido.

una solución pragmática sería a init vector con n entradas + 1 y restringir el acceso a 0..n-1 (ya que este código ya hace).

void foo (int n) { 
    std::vector<char> scoped_array (n+1); 
    char* pointer = &scoped_array[0]; 
    file.read (pointer , n); 
    for (int i = 0; i < n; ++i) { 
    //do something 
    } 
} 

Answer 4

Esto trajo una pregunta interesante, en mi opinión, que rápidamente le pregunté here. En su caso, se puede evitar el uso de punteros de la siguiente manera:

template<class InputIterator, class OutputIterator> 
OutputIterator copy_n(InputIterator first, InputIterator last, OutputIterator result, std::size_t n) 
{ 
    for (std::size_t i = 0; i < n; i++) { 
     if (first == last) 
      break; 
     else 
      *result++ = *first++; 
    } 
    return result; 
} 

std::ifstream file("path_to_file"); 
std::vector<char> buffer(n); 
copy_n(std::istream_iterator<char>(file), 
     std::istream_iterator<char>(), 
     std::back_insert_iterator<vector<char> >(buffer), 
     n); 

Esto copia el contenido del archivo en una memoria intermedia n caracteres a la vez. Cuando itere sobre el búfer, use:

for (std::vector<char>::iterator it = buffer.begin(); it != buffer.end(); it++) 

en lugar de un contador.

Answer 5

En lo que respecta al estándar C++, operator[] no se garantiza que no se compruebe, es solo que (a diferencia de at()) no está garantizado para comprobar.

Es de esperar que en una implementación sin comprobación, &scoped_array[scoped_array.size()] daría como resultado un puntero legal dentro o fuera de una matriz asignada por el vector. Esto no está explícitamente garantizado, pero para una implementación dada, usted puede verificarlo mirando su fuente. Para un vector vacío, puede que no haya ninguna asignación (como optimización) y no veo nada en la parte vector del estándar que define el resultado de scoped_array[0] que no sea la tabla 68.

Pasando de tabla 68, puede decir que el resultado de su expresión es &*(a.begin() + 0), que desreferencia de forma ilegal un iterador de extremo a extremo. Si el iterador de vector de su implementación es solo un puntero, probablemente se salga con la suya, si no, no, y obviamente el suyo no.

Olvidé los resultados del argumento de si &*, en un puntero que no se debe desreferenciar, no funciona o no. IIRC no está claro en el estándar (alguna ambigüedad en alguna parte), lo que provocó solicitudes para arreglar el estándar para hacerlo explícitamente legal. Esto sugiere que de hecho funciona en todas o la mayoría de las implementaciones conocidas.

Personalmente, no confío en esto, y no desactivo la comprobación. Me reescribir su código:

char* pointer = (scoped_array.size() > 0) ? &scoped_array[0] : 0; 

O en este caso simplemente:

char* pointer = (n > 0) ? &scoped_array[0] : 0; 

Sólo se ve mal a mí utilizar el índice n de un vector sin saber que el tamaño es al menos n + 1, independientemente de si realmente funciona en su implementación una vez que haya desactivado la verificación.

Answer 6

operator [] devuelve una referencia y, por lo tanto, invocarla en un vector vacío no debe definirse.

Después de todo, ¿a qué artículo se debe hacer referencia cuando no hay elementos? operator [] tendría que devolver una referencia nula o una referencia totalmente inválida. Ambos resultados resultarían en un comportamiento indefinido.

Así que sí, estuvo usando un comportamiento indefinido todo el tiempo. Las comprobaciones no obligatorias pero constantes de Visual Studio en operator [] acaban de revelar ese hecho.

Answer 7

¿Podría usar iteradores en lugar de punteros?

{ 
    std::vector<char> scoped_array (size); 
    std::vector<char>::iterator pointer = scoped_array.begin(); 

    //do work 

} // exception safe deallocation