Non riesco a capire in questo modo per calcolare il quadrato di un numero

Ho trovato una funzione che calcola il quadrato di un numero:

int p(int n) {
    int a[n]; //works on C99 and above
    return (&a)[n] - a;
}

Restituisce il valore di n ² . La domanda è: come lo fa? Dopo un po 'di test, ho scoperto che tra (&a)[k]e (&a)[k+1]è sizeof(a)/ sizeof(int). Perché?

Ovviamente un hack ... ma un modo di quadrare un numero senza usare l' *operatore (questo era un requisito per il concorso di codifica).

(&a)[n] 

equivale a un puntatore intalla posizione

(a + sizeof(a[n])*n)

e quindi l'intera espressione è

  (&a)[n] -a 

= (a + sizeof(a[n])*n -a) /sizeof(int)

= sizeof(a[n])*n / sizeof(int)
= sizeof(int) * n * n / sizeof(int)
= n * n

Per capire questo hack, prima devi capire la differenza del puntatore, cioè cosa succede quando vengono sottratti due puntatori che puntano su elementi dello stesso array ?

Quando un puntatore viene sottratto da un altro, il risultato è la distanza (misurata in elementi dell'array) tra i puntatori. Quindi, se ppunta a a[i]e qpunta a a[j], allora p - qè uguale ai - j .

C11: 6.5.6 Operatori additivi (p9):

Quando vengono sottratti due puntatori , entrambi devono puntare a elementi dello stesso oggetto array o uno oltre l'ultimo elemento dell'oggetto array; il risultato è la differenza dei pedici dei due elementi dell'array . [...].
In altre parole, se le espressioni Pe Qpuntano, rispettivamente, agli elementi i-th e j-th di un oggetto array, l'espressione (P)-(Q)ha il valore ai−j condizione che il valore si adatti a un oggetto di tipo ptrdiff_t.

Ora mi aspetto che tu sia a conoscenza della conversione del nome dell'array in puntatore, che aconverte in puntatore al primo elemento dell'array a. &aè l'indirizzo dell'intero blocco di memoria, ovvero è un indirizzo di array a. La figura seguente ti aiuterà a capire ( _{leggi questa risposta per una spiegazione dettagliata} ):

Questo ti aiuterà a capire perché ae perché &aha lo stesso indirizzo e come (&a)[i]è l'indirizzo del ^mio array (della stessa dimensione di quello di a).

Quindi, la dichiarazione

return (&a)[n] - a; 

è equivalente a

return (&a)[n] - (&a)[0];  

e questa differenza fornirà il numero di elementi tra i puntatori (&a)[n]e (&a)[0], che sono narray ciascuno di n intelementi. Pertanto, gli elementi dell'array totale sono n*n= n² .

NOTA:

C11: 6.5.6 Operatori additivi (p9):

Quando vengono sottratti due puntatori, entrambi devono puntare a elementi dello stesso oggetto array o uno oltre l'ultimo elemento dell'oggetto array ; il risultato è la differenza dei pedici dei due elementi dell'array. La dimensione del risultato è definita dall'implementazione e il suo tipo (un tipo intero con segno) è ptrdiff_tdefinito <stddef.h>nell'intestazione. Se il risultato non è rappresentabile in un oggetto di quel tipo, il comportamento non è definito.

Poiché (&a)[n]né punta a elementi dello stesso oggetto array né a uno oltre l'ultimo elemento dell'oggetto array, (&a)[n] - ainvocherà un comportamento indefinito .

Inoltre, è meglio cambiare il tipo di funzione di ritorno pin ptrdiff_t.

aè una matrice (variabile) di n int.

&aè un puntatore a un array (variabile) di n int.

(&a)[1]è un puntatore di intuno intoltre l'ultimo elemento dell'array. Questo puntatore è n intelementi dopo &a[0].

(&a)[2]è un puntatore di intuno intoltre l'ultimo elemento dell'array di due array. Questo puntatore è 2 * n intelementi dopo &a[0].

(&a)[n]è un puntatore di intuno intoltre l'ultimo elemento dell'array di narray. Questo puntatore è n * n intelementi dopo &a[0]. Basta sottrarre &a[0]o ae si dispone n.

Naturalmente questo è un comportamento tecnicamente indefinito anche se funziona sul tuo computer in quanto (&a)[n]non punta all'interno dell'array o supera l'ultimo elemento dell'array (come richiesto dalle regole C dell'aritmetica del puntatore).

Se hai due puntatori che puntano a due elementi dello stesso array, la sua differenza produrrà il numero di elementi tra questi puntatori. Ad esempio, questo frammento di codice genererà 2.

int a[10];

int *p1 = &a[1];
int *p2 = &a[3];

printf( "%d\n", p2 - p1 ); 

Ora consideriamo l'espressione

(&a)[n] - a;

In questa espressione aha tipo int *e punta al suo primo elemento.

L'espressione &aha tipo int ( * )[n]e punta alla prima riga della matrice bidimensionale immaginata. Il suo valore corrisponde al valore di asebbene i tipi siano diversi.

( &a )[n]

è n-esimo elemento di questo array bidimensionale immaginato e ha tipo int[n]Cioè è l'ennesima riga dell'array di imaging. In espressione (&a)[n] - aviene convertito nell'indirizzo del suo primo elemento e ha tipo `int *.

Quindi tra (&a)[n]e aci sono n righe di n elementi. Quindi la differenza sarà uguale a n * n.

Expression     | Value                | Explanation
a              | a                    | point to array of int elements
a[n]           | a + n*sizeof(int)    | refer to n-th element in array of int elements
-------------------------------------------------------------------------------------------------
&a             | a                    | point to array of (n int elements array)
(&a)[n]        | a + n*sizeof(int[n]) | refer to n-th element in array of (n int elements array)
-------------------------------------------------------------------------------------------------
sizeof(int[n]) | n * sizeof(int)      | int[n] is a type of n-int-element array

Così,

1. tipo di (&a)[n] è int[n]puntatore
2. tipo di a è intpuntatore

Ora l'espressione (&a)[n]-aesegue una sottostrazione del puntatore:

  (&a)[n]-a
= ((a + n*sizeof(int[n])) - a) / sizeof(int)
= (n * sizeof(int[n])) / sizeof(int)
= (n * n * sizeof(int)) / sizeof(int)
= n * n