Puntero C a matriz / matriz de desambiguación de punteros

¿Cuál es la diferencia entre las siguientes declaraciones:

int* arr1[8];
int (*arr2)[8];
int *(arr3[8]);

¿Cuál es la regla general para entender declaraciones más complejas?

int* arr[8]; // An array of int pointers.
int (*arr)[8]; // A pointer to an array of integers

El tercero es el mismo que el primero.

La regla general es la precedencia del operador . Puede volverse aún más complejo a medida que los punteros de función entran en escena.

Use el programa cdecl , como lo sugiere K&R.

$ cdecl
Type `help' or `?' for help
cdecl> explain int* arr1[8];
declare arr1 as array 8 of pointer to int
cdecl> explain int (*arr2)[8]
declare arr2 as pointer to array 8 of int
cdecl> explain int *(arr3[8])
declare arr3 as array 8 of pointer to int
cdecl>

También trabaja de la otra manera.

cdecl> declare x as pointer to function(void) returning pointer to float
float *(*x)(void )

No sé si tiene un nombre oficial, pero lo llamo el Right-Left Thingy (TM).

Comience en la variable, luego vaya a la derecha, a la izquierda, a la derecha ... y así sucesivamente.

int* arr1[8];

arr1 es una matriz de 8 punteros a enteros.

int (*arr2)[8];

arr2 es un puntero (el paréntesis bloquea la derecha-izquierda) a una matriz de 8 enteros.

int *(arr3[8]);

arr3 es una matriz de 8 punteros a enteros.

Esto debería ayudarte con declaraciones complejas.

int *a[4]; // Array of 4 pointers to int

int (*a)[4]; //a is a pointer to an integer array of size 4

int (*a[8])[5]; //a is an array of pointers to integer array of size 5 

La respuesta para los dos últimos también se puede deducir de la regla de oro en C:

La declaración sigue al uso.

int (*arr2)[8];

¿Qué pasa si desreferencias arr2? Obtiene una matriz de 8 enteros.

int *(arr3[8]);

¿Qué sucede si tomas un elemento de arr3? Obtienes un puntero a un entero.

Esto también ayuda cuando se trata de punteros a funciones. Para tomar el ejemplo de sigjuice:

float *(*x)(void )

¿Qué pasa cuando desreferencias x? Obtiene una función que puede llamar sin argumentos. ¿Qué pasa cuando lo llamas? Devolverá un puntero a a float.

Sin embargo, la precedencia del operador siempre es complicada. Sin embargo, el uso de paréntesis también puede ser confuso porque la declaración sigue al uso. Al menos, para mí, intuitivamente se arr2ve como una matriz de 8 punteros a ints, pero en realidad es al revés. Solo toma un tiempo acostumbrarse. Razón suficiente para agregar siempre un comentario a estas declaraciones, si me preguntas :)

editar: ejemplo

Por cierto, me topé con la siguiente situación: una función que tiene una matriz estática y que usa la aritmética del puntero para ver si el puntero de la fila está fuera de los límites. Ejemplo:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define NUM_ELEM(ar) (sizeof(ar) / sizeof((ar)[0]))

int *
put_off(const int newrow[2])
{
    static int mymatrix[3][2];
    static int (*rowp)[2] = mymatrix;
    int (* const border)[] = mymatrix + NUM_ELEM(mymatrix);

    memcpy(rowp, newrow, sizeof(*rowp));
    rowp += 1;
    if (rowp == border) {
        rowp = mymatrix;
    }

    return *rowp;
}

int
main(int argc, char *argv[])
{
    int i = 0;
    int row[2] = {0, 1};
    int *rout;

    for (i = 0; i &lt; 6; i++) {
        row[0] = i;
        row[1] += i;
        rout = put_off(row);
        printf("%d (%p): [%d, %d]\n", i, (void *) rout, rout[0], rout[1]);
    }

    return 0;
}

Salida:

0 (0x804a02c): [0, 0]
1 (0x804a034): [0, 0]
2 (0x804a024): [0, 1]
3 (0x804a02c): [1, 2]
4 (0x804a034): [2, 4]
5 (0x804a024): [3, 7]

Tenga en cuenta que el valor del borde nunca cambia, por lo que el compilador puede optimizarlo. Esto es diferente de lo que podría querer usar inicialmente const int (*border)[3]:: que declara el borde como un puntero a una matriz de 3 enteros que no cambiará el valor mientras exista la variable. Sin embargo, ese puntero puede apuntar a cualquier otra matriz de este tipo en cualquier momento. En cambio, queremos ese tipo de comportamiento para el argumento (porque esta función no cambia ninguno de esos enteros). La declaración sigue al uso.

(pd: ¡siéntase libre de mejorar esta muestra!)

typedef int (*PointerToIntArray)[];
typedef int *ArrayOfIntPointers[];

Como regla general, los operadores unitarios adecuados (como [], (), etc.) tienen preferencia sobre los de izquierda. Entonces,int *(*ptr)()[]; lo sería un puntero que apunta a una función que devuelve una matriz de punteros a int (obtenga los operadores correctos tan pronto como pueda a medida que sale del paréntesis)

Creo que podemos usar la regla simple ...

example int * (*ptr)()[];
start from ptr 

" ptres un puntero para" ir hacia la derecha ... es ")" ahora ir a la izquierda es un "(" salir a la derecha "()" entonces "a una función que no toma argumentos" ir a la izquierda "y devuelve un puntero" ir derecha "a una matriz" ir a la izquierda "de enteros"

Aquí hay un sitio web interesante que explica cómo leer tipos complejos en C: http://www.unixwiz.net/techtips/reading-cdecl.html

Así es como lo interpreto:

int *something[n];

Nota sobre la precedencia: el operador de subíndice de matriz ( []) tiene mayor prioridad que el operador de desreferencia ( *).

Entonces, aquí aplicaremos el []antes *, haciendo que la declaración sea equivalente a:

int *(something[i]);

Observe cómo una declaración tiene sentido: int numsignifica numes unint , int *ptro int (*ptr)significa, (valor en ptr) es un int, lo que hace ptrun puntero a int.

Esto se puede leer como, (el valor del (valor en el índice i-ésimo de algo)) es un número entero. Entonces, (el valor en el i-ésimo índice de algo) es un (puntero entero), lo que hace que algo sea una matriz de punteros enteros.

En el segundo

int (*something)[n];

Para que esta afirmación tenga sentido, debe estar familiarizado con este hecho:

Nota sobre la representación del puntero de la matriz: somethingElse[i]es equivalente a*(somethingElse + i)

Entonces, reemplazando somethingElsecon (*something), obtenemos *(*something + i), que es un número entero según la declaración. Entonces,(*something) nos dio una matriz, que hace algo equivalente a (puntero a una matriz) .

Supongo que la segunda declaración es confusa para muchos. Aquí hay una manera fácil de entenderlo.

Tengamos una variedad de enteros, es decir int B[8] .

También tengamos una variable A que apunta a B. Ahora, el valor en A es B, es decir (*A) == B . Por lo tanto, A apunta a una matriz de enteros. En su pregunta, arr es similar a A.

Del mismo modo, en int* (*C) [8], C es un puntero a una matriz de punteros a entero.

int *arr1[5]

En esta declaración, arr1hay una matriz de 5 punteros a enteros. Motivo: Los corchetes tienen mayor prioridad sobre * (operador de desreferencia). Y en este tipo, el número de filas es fijo (5 aquí), pero el número de columnas es variable.

int (*arr2)[5]

En esta declaración, arr2es un puntero a una matriz entera de 5 elementos. Motivo: Aquí, los corchetes () tienen mayor prioridad que []. Y en este tipo, el número de filas es variable, pero el número de columnas es fijo (5 aquí).

En puntero a un entero si el puntero se incrementa, entonces pasa al siguiente entero.

en la matriz del puntero si se incrementa el puntero, salta a la siguiente matriz