C puntatore all'array / array di puntatori disambiguazione

Qual è la differenza tra le seguenti dichiarazioni:

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

Qual è la regola generale per comprendere dichiarazioni più complesse?

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

Il terzo è uguale al primo.

La regola generale è la precedenza dell'operatore . Può diventare ancora più complesso quando i puntatori a funzione entrano in scena.

Usa il programma cdecl , come suggerito da 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>

Funziona anche nell'altro modo.

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

Non so se abbia un nome ufficiale, ma lo chiamo il Thingy (TM) di destra e di sinistra.

Inizia dalla variabile, poi vai a destra, a sinistra, a destra ... e così via.

int* arr1[8];

arr1 è un array di 8 puntatori a numeri interi.

int (*arr2)[8];

arr2 è un puntatore (la parentesi blocca il lato destro-sinistro) verso un array di 8 numeri interi.

int *(arr3[8]);

arr3 è un array di 8 puntatori a numeri interi.

Questo dovrebbe aiutarti con dichiarazioni complesse.

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 risposta per gli ultimi due può anche essere dedotta dalla regola d'oro in C:

La dichiarazione segue l'uso.

int (*arr2)[8];

Cosa succede se fai la dereferenza arr2? Ottieni una matrice di 8 numeri interi.

int *(arr3[8]);

Cosa succede se prendi un elemento da arr3? Ottieni un puntatore a un numero intero.

Questo aiuta anche quando si tratta di puntatori a funzioni. Per prendere l'esempio di sigjuice:

float *(*x)(void )

Cosa succede quando si dereference x? Ottieni una funzione che puoi chiamare senza argomenti. Cosa succede quando lo chiami? Restituirà un puntatore a float.

La precedenza dell'operatore è sempre difficile, però. Tuttavia, l'uso delle parentesi può anche essere fonte di confusione perché la dichiarazione segue l'uso. Almeno, per me, arr2sembra intuitivamente come un array di 8 puntatori a inte, ma in realtà è il contrario. Ci vuole solo un po 'per abituarsi. Motivo sufficiente per aggiungere sempre un commento a queste dichiarazioni, se me lo chiedi :)

modifica: esempio

A proposito, mi sono appena imbattuto nella seguente situazione: una funzione che ha una matrice statica e che utilizza l'aritmetica del puntatore per vedere se il puntatore di riga è fuori limite. Esempio:

#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;
}

Produzione:

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

Si noti che il valore di border non cambia mai, quindi il compilatore può ottimizzarlo via. Questo è diverso da quello che potresti voler usare inizialmente const int (*border)[3]:: che dichiara il bordo come un puntatore a un array di 3 numeri interi che non cambieranno valore finché esiste la variabile. Tuttavia, tale puntatore può essere puntato su qualsiasi altro array in qualsiasi momento. Vogliamo quel tipo di comportamento per l'argomento, invece (perché questa funzione non cambia nessuno di questi numeri interi). La dichiarazione segue l'uso.

(ps: sentiti libero di migliorare questo campione!)

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

Come regola generale, gli operatori unari destra (come [], (), ecc) prendere preferenza rispetto a quelle di sinistra. Quindi, int *(*ptr)()[];sarebbe un puntatore che punta a una funzione che restituisce una matrice di puntatori a int (ottenere gli operatori giusti appena possibile quando si esce dalla parentesi)

Penso che possiamo usare la semplice regola ..

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

" ptrè un puntatore a" vai verso destra ..it ")" ora vai a sinistra è un "(" esci vai a destra "()" così "a una funzione che non accetta argomenti" vai a sinistra "e restituisce un puntatore" vai a destra "in un array" vai a sinistra "di numeri interi"

Ecco un sito interessante che spiega come leggere tipi complessi in C: http://www.unixwiz.net/techtips/reading-cdecl.html

Ecco come lo interpreto:

int *something[n];

Nota sulla precedenza: l'operatore di sottoscrizione dell'array ( []) ha una priorità più alta dell'operatore di dereference ( *).

Quindi, qui applicheremo il []precedente *, rendendo la dichiarazione equivalente a:

int *(something[i]);

Nota su come ha senso una dichiarazione: int numsignifica numè unint , int *ptro int (*ptr)mezzo, (valore at ptr) è un int, che indica un ptrpuntatore a int.

Questo può essere letto come, (il valore di (valore all'indice del qualcosa)) è un numero intero. Quindi, (valore all'ultimo indice di qualcosa) è un (puntatore intero), che rende il qualcosa un array di puntatori interi.

Nel secondo,

int (*something)[n];

Per dare un senso a questa affermazione, devi conoscere questo fatto:

Nota sulla rappresentazione puntatore dell'array: somethingElse[i]è equivalente a*(somethingElse + i)

Quindi, sostituendo somethingElsecon (*something), otteniamo *(*something + i), che è un numero intero come da dichiarazione. Quindi, (*something)ci ha dato un array, che rende equivalente a (puntatore a un array) .

Immagino che la seconda dichiarazione sia confusa per molti. Ecco un modo semplice per capirlo.

Consente di disporre di una matrice di numeri interi, ad es int B[8].

Diamo anche una variabile A che punta a B. Ora, il valore in A è B, cioè (*A) == B. Quindi A punta a una matrice di numeri interi. Nella tua domanda, arr è simile ad A.

Allo stesso modo, in int* (*C) [8], C è un puntatore a un array di puntatori a numeri interi.

int *arr1[5]

In questa dichiarazione, arr1è un array di 5 puntatori a numeri interi. Motivo: le parentesi quadre hanno una precedenza maggiore su * (operatore di dereferncing). E in questo tipo, il numero di righe è fisso (5 qui), ma il numero di colonne è variabile.

int (*arr2)[5]

In questa dichiarazione, arr2è un puntatore a un array intero di 5 elementi. Motivo: qui, le parentesi () hanno una precedenza maggiore di []. E in questo tipo, il numero di righe è variabile, ma il numero di colonne è fisso (5 qui).

Nel puntatore a un numero intero se il puntatore viene incrementato, passa al numero intero successivo.

nell'array di puntatore se il puntatore viene incrementato, passa all'array successivo