¿Son los vectores más rigurosos al marcar fuera de los límites que las matrices de montón?

Question

¿Qué tan riguroso es el control de límites en los vectores en comparación con las matrices de montón? ¿Cómo está comprobando los límites y cómo se compara con la forma en que se comprueba una matriz de montón?

Answer 1

Un vector hará lo comprobación de límites si se utiliza la función at(), por ejemplo:

std::vector<int> v(5); 
v.at(3) = 10; 
v.at(5) = 20; // throws an exception, std::out_of_range 

Sin embargo, si se utiliza operator[], no hay comprobación de límites. (Y el acceso a elementos inexistentes conduce a un comportamiento indefinido.)

_{Cabe señalar, sin embargo, que la mayoría de las implementaciones tendrán la posibilidad de incluir la comprobación de límites en todos los iteradores, que se discute en las respuestas here. De forma predeterminada, VS2008 y siguientes tienen activado Debug and Release, VS2010 solo lo hace en Debug. gcc requiere que defina _GLIBCXX_DEBUG para obtener los iteradores marcados.}

Answer 2

Que va a ser la implementación definida, el vector contract no ofrece garantías de comprobación consolidadas. Pero, usted sabe una cosa con certeza, será no peor que una matriz de montón.

En mi aplicación SGI:

• vector::operator[] no se comprueba
• vector::at() está obligado comprobado

A partir de la definición del archivo de cabecera de operator[]:

/** 
    * @brief Subscript access to the data contained in the %vector. 
    * @param n The index of the element for which data should be 
    * accessed. 
    * @return Read-only (constant) reference to data. 
    * 
    * This operator allows for easy, array-style, data access. 
    * Note that data access with this operator is unchecked and 
    * out_of_range lookups are not defined. (For checked lookups 
    * see at().) 
    */ 

Y para vector::at() :

/** 
    * @brief Provides access to the data contained in the %vector. 
    * @param n The index of the element for which data should be 
    * accessed. 
    * @return Read/write reference to data. 
    * @throw std::out_of_range If @a n is an invalid index. 
    * 
    * This function provides for safer data access. The parameter 
    * is first checked that it is in the range of the vector. The 
    * function throws out_of_range if the check fails. 
    */ 

Answer 3

En una implementación típica, las matrices no se comprueban en absoluto, independientemente de la asignación. std::vector requiere comprobación de límites en at(). El acceso fuera de límites con operator[] proporciona un comportamiento indefinido, por lo que también es posible establecer límites al verificarlo, pero esto es bastante inusual.

Lo que es más importante, sin embargo, aconsejaría generalmente usar algoritmos que en su mayoría eliminen la preocupación en primer lugar. Cuando haces algo como: for (i=0; i<N; i++), es bastante fácil para N ser lo incorrecto. Cuando usa algorithm(x.begin(), x.end(), ...);, es mucho más fácil obtener un grado razonable de certeza de que su lógica es correcta.