Não consigo entender essa maneira de calcular o quadrado de um número

Eu encontrei uma função que calcula o quadrado de um número:

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

Retorna o valor de n ² . A questão é: como isso acontece? Após um pequeno teste, descobri que entre (&a)[k]e (&a)[k+1]é sizeof(a)/ sizeof(int). Por que é que?

Obviamente, um hack ... mas uma maneira de quadrilhar um número sem usar o *operador (este era um requisito de concurso de codificação).

(&a)[n] 

é equivalente a um ponteiro para intno local

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

e assim toda a expressão é

  (&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

Para entender esse hack, primeiro você precisa entender a diferença de ponteiro, ou seja, o que acontece quando dois ponteiros apontando para elementos da mesma matriz são subtraídos?

Quando um ponteiro é subtraído de outro, o resultado é a distância (medida em elementos da matriz) entre os ponteiros. Então, se paponta para a[i]e qaponta para a[j], então p - qé igual ai - j .

C11: 6.5.6 Operadores aditivos (p9):

Quando dois ponteiros são subtraídos , ambos apontam para elementos do mesmo objeto de matriz ou um após o último elemento do objeto de matriz; o resultado é a diferença dos subscritos dos dois elementos da matriz . [...]
Em outras palavras, se as expressões Pe Qapontarem para, respectivamente, os elementos -ésimo i-ésimo j-ésimo de um objeto de matriz, a expressão (P)-(Q)terá o valori−j desde que o valor se ajuste a um objeto do tipo ptrdiff_t.

Agora, espero que você esteja ciente da conversão do nome da matriz em ponteiro, aconverta em ponteiro no primeiro elemento da matriz a. &aé o endereço de todo o bloco de memória, ou seja, é um endereço do array a. A figura abaixo ajudará você a entender ( _{leia esta resposta para obter explicações detalhadas} ):

Isso ajudará você a entender que por isso ae &atem o mesmo endereço e como (&a)[i]é o endereço do i ^th array (de mesmo tamanho que a do a).

Então, a afirmação

return (&a)[n] - a; 

é equivalente a

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

e essa diferença fornecerá o número de elementos entre os ponteiros (&a)[n]e (&a)[0], que são nmatrizes cada um dos n intelementos. Portanto, o total de elementos da matriz é n*n= n² .

NOTA:

C11: 6.5.6 Operadores aditivos (p9):

Quando dois ponteiros são subtraídos, ambos apontam para elementos do mesmo objeto de matriz ou um após o último elemento do objeto de matriz ; o resultado é a diferença dos subscritos dos dois elementos da matriz. O tamanho do resultado é definido pela implementação e seu tipo (um tipo inteiro assinado) é ptrdiff_tdefinido no <stddef.h>cabeçalho. Se o resultado não for representável em um objeto desse tipo, o comportamento será indefinido.

Como (&a)[n]nem pontos para elementos do mesmo objeto de matriz nem um após o último elemento do objeto de matriz, (&a)[n] - ainvocará um comportamento indefinido .

Observe também que é melhor alterar o tipo de retorno da função ppara ptrdiff_t.

aé uma matriz (variável) de n int.

&aé um ponteiro para uma matriz (variável) de n int.

(&a)[1]é um ponteiro de intum intpassado o último elemento da matriz. Este ponteiro é n intelementos depois &a[0].

(&a)[2]é um ponteiro de intum intpassado o último elemento da matriz de duas matrizes. Este ponteiro é 2 * n intelementos depois &a[0].

(&a)[n]é um ponteiro de intum intpassado o último elemento da matriz de nmatrizes. Este ponteiro é n * n intelementos depois &a[0]. Basta subtrair &a[0]ou ae você tem n.

É claro que esse é um comportamento tecnicamente indefinido, mesmo que funcione em sua máquina, pois (&a)[n]não aponta para dentro da matriz ou ultrapassa o último elemento da matriz (conforme exigido pelas regras C da aritmética dos ponteiros).

Se você tiver dois ponteiros que apontam para dois elementos da mesma matriz, sua diferença produzirá o número de elementos entre esses ponteiros. Por exemplo, este trecho de código produzirá 2.

int a[10];

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

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

Agora vamos considerar a expressão

(&a)[n] - a;

Nesta expressão atem tipo int *e aponta para seu primeiro elemento.

A expressão &atem tipo int ( * )[n]e aponta para a primeira linha da matriz bidimensional da imagem. Seu valor corresponde ao valor dos atipos diferentes.

( &a )[n]

é o n-ésimo elemento dessa matriz bidimensional da imagem e tem o tipo int[n]Isso é a n-ésima linha da matriz da imagem. Na expressão, (&a)[n] - aele é convertido no endereço do seu primeiro elemento e tem o tipo `int *.

Portanto, entre (&a)[n]e aexistem n linhas de n elementos. Então a diferença será igual 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

Portanto,

1. tipo de (&a)[n]é int[n]ponteiro
2. tipo de aé intponteiro

Agora a expressão (&a)[n]-aexecuta uma subtração de ponteiro:

  (&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