validez del código

Question

Consideremos el siguiente código:

void populate(int *arr) 
{ 
    for(int j=0;j<4;++j) 
     arr[j]=0; 
} 

int main() 
{ 
    int array[2][2]; 
    populate(&array[0][0]); 
} 

Hubo una discusión con respecto a esto en una comunidad local si el código es válido o no (¿Se supone que mencionar su nombre?). Un tipo estaba diciendo que invoca UB porque viola

C++ estándar ($ 5.7/5 [expr.add])

"Si tanto el operando puntero y el punto resultado a los elementos de la misma array, o uno pasado el último elemento del objeto de matriz, la evaluación no producirá un desbordamiento; ; de lo contrario, el comportamiento no está definido. "

Pero no veo nada de malo en el código, el código está perfectamente bien para mí.

Entonces, solo quiero saber si este código es válido o no? ¿Me estoy perdiendo de algo?

Answer 1

Su array es dos matrices de int[2], mientras que su función populate() lo trata como una única matriz de int[4]. Dependiendo de cómo exactamente el compilador decida alinear los elementos de array, esto puede no ser una suposición válida.

Específicamente, cuando j es 2 y se intenta acceder a arr[2], esto es fuera de los límites de main 's array[0] y es, por tanto, inválida.

Answer 2

Eso no siempre va a funcionar. C tiene matrices de matrices, no matrices 2D. Las sub-matrices no siempre se especifican para que sean contiguas en la memoria (las matrices estáticas pueden ser, verifique el estándar C/C++) En este ejemplo en particular, sospecho que funciona correctamente. Sin embargo, si hubiera asignado dinámicamente la memoria que se está transfiriendo, posiblemente fallaría, ya que malloc (o nuevo) podría haber separado los subarrays.

Si, sin embargo, desea caminar linealmente hacia abajo en la memoria '2d', puede construir un acceso 2D en una matriz 1D y funcionará bien y cosas como memset funcionarán contra la matriz 1D.

Answer 3

Tiene una matriz de matrices. array[1] sigue array[0] en memoria, porque las matrices son contiguas. Si p == array[0], entonces p[1] sigue p[0], porque las matrices son contiguas. Entonces, tienes razón: toda la memoria para array es contigua.

En las imágenes, array se parece así.

+-----------------+-----------------+ 
|  [0]  |  [1]  | 
+-----------------+-----------------+ 

Ahora, vamos a romper array[0] y array[1], se ven de forma individual como esto:

+--------+--------+ 
| [0] | [1] |   
+--------+--------+ 

Por lo tanto, la imagen final es:

+--------+--------+--------+--------+ 
| [0][0] | [0][1] | [1][0] | [1][1] | 
+--------+--------+--------+--------+ 

Ahora, la pregunta es, ¿puede accedes a esta memoria contigua tal como eres. La respuesta es que no está garantizada por el estándar.Las matrices son contiguas, pero el estándar no permite la indexación de la forma en que lo ha hecho. En otras palabras:

&array[0][0]+2 == &array[1][0], pero (&a[0][0] + 2) + 1 no está definido, mientras que &a[1][0] + 1 es válido. Si esto parece extraño, lo es, pero según la cita que publicaste del estándar, solo puedes calcular un puntero que se encuentre dentro de una matriz o como mucho después de la matriz (sin desreferenciar ese puntero "anterior") .

En la práctica, dudo que esto fallaría en cualquier lugar, pero al menos de acuerdo con la norma, su código no es válido debido a un comportamiento indefinido.

Consulte this post on comp.lang.c también.

Answer 4

En C todo se almacena en segmentos de memoria lineal. Está pasando la dirección de a[0][0] que sería igual que la dirección de a[0] así que a[i][j] es lo mismo que a[i*ColSize+j] porque todo se almacena linealmente. Pero si asigna dinámicamente la memoria, fallaría porque, en ese momento, es posible que no se almacenen todas las filas en una ubicación contigua. entonces a[i][j] sería *(&a[i]+j).