¿Es malo hacer referencia a los elementos de la matriz de acceso a través de la aritmética del puntero en lugar del operador []?

Recién comencé a aprender a programar en C, y para mejorar mi comprensión de los punteros y las matrices, intenté referirme a los elementos de una matriz sin crear ningún puntero:

for(k1 = 0; k1 < ROW; k1++){
    for(k2 = 0; k2 < COLUMN; k2++){

        array[k1][k2] = k1*COLUMN + k2 + 1;

        printf("[%d][%d] = %d\n", k1, k2, *(array[k1] + k2));

    }
}

Todo el código se compila y se ejecuta sin problemas.

Me imagino que tener que crear un puntero para cada matriz en un gran código fuente parece ser muy ineficiente.

Entonces, en lugar de tener la dirección de una matriz almacenada y recuperada usando un puntero, ¿es una mala práctica de programación usar la dirección de la matriz directamente, como se muestra arriba?

Es "malo" solo en la medida en que sea menos legible. a[x]es lo mismo que *(a+x), así que no hay diferencia en eficiencia o comportamiento (de hecho, x[a]también funcionará). Es solo que a[x]generalmente es mucho más intuitivo para nosotros los humanos.

Pero eso no quiere decir que la legibilidad no sea un gran problema. Para ver qué tan grande, piense cómo "leería" estas dos expresiones si las viera en código:

• *(a+x)= "La cosita señalada por la suma del puntero ay el entero x"
• a[x]= "El xmiembro th de la matriz a"

Del mismo modo, cuando necesita hacer referencia a la dirección de un elemento de matriz:

• (a+x)= "La suma del puntero ay el entero x"
• &a[x]= "La dirección del xmiembro th de la matriz a"

La mayoría de las veces, las []versiones son más fáciles de entender cuando se busca código no trivial que opera en varias matrices diferentes (especialmente matrices de matrices). Es por eso que el []operador existe en primer lugar.

PD: Hacer este tipo de cosas estrictamente como un ejercicio de aprendizaje es una muy buena idea. Es importante comprender que las matrices realmente son solo punteros y compensaciones.

Sí, es una mala práctica, pero no por razones de ineficiencia.

El operador de matriz utiliza un puntero aritmético debajo del capó, por lo que son igualmente eficientes.

El problema con el puntero aritmétrico es que es muy propenso a errores y es más difícil de leer.

Regla general: no utilice el puntero aritmétrico a menos que sea necesario.

Refresque su aprendizaje c, acaba de descubrir uno de los trabalenguas pequeños. No está haciendo aritmética de puntero en una matriz, sino una matriz de punteros. No es posible hacer aritmética de puntero en matrices. Una matriz se descompone en un puntero, pero no es un puntero del tipo en sí mismo. Lo que tienes (ver comentario de cmaster) es

int *array[]; //This is a array to pointers of type *int. 

array[k1] + k2; //This is pointer arithmetic on one pointer stored in the array  

Anular la referencia a este puntero le da el valor al que apunta su puntero recién calculado. Generalmente no tiene sentido hacer lo que estás haciendo. Pero puede linealizar la matriz y luego una zancada, como esta.

int array[y_dim*x_dim]; 
int index = x_dim*y + x; 
array[index]; //Gives you the element in x, y!

Stride her is x_dim. ¡Espero que mi respuesta sea aclaradora!