Не могу понять, как рассчитать квадрат числа

Я нашел функцию, которая вычисляет квадрат числа:

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

Возвращает значение n ² . Вопрос в том, как это сделать? После небольшого тестирования я обнаружил, что между (&a)[k]и (&a)[k+1]есть sizeof(a)/ sizeof(int). Это почему?

Очевидно, что взломать ... но способ возведения в квадрат числа без использования *оператора (это было требование конкурса кодирования).

(&a)[n] 

эквивалентно указателю intна местоположение

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

и, таким образом, все выражение

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

Чтобы понять этот хак, сначала нужно понять разницу в указателях, т. Е. Что происходит, когда два указателя указывают на элементы одного массива вычитаются ?

Когда один указатель вычитается из другого, результатом является расстояние (измеренное в элементах массива) между указателями. Итак, если pуказывает на a[i]и qуказывает на a[j], тоp - q равноi - j .

C11: 6.5.6 Аддитивные операторы (p9):

Когда вычтены два указателя , оба должны указывать на элементы одного и того же объекта массива или один после последнего элемента объекта массива; Результатом является разница индексов двух элементов массива . [...].
Другими словами, если выражения Pи Qуказывают, соответственно, на i-й и j-й элементы объекта массива, выражение (P)-(Q)имеет значениеi−j при условии, что это значение соответствует объекту типа ptrdiff_t.

Теперь я ожидаю, что вы знаете о преобразовании имени массива в указатель, aпреобразует указатель на первый элемент массива a. &aэто адрес всего блока памяти, т.е. это адрес массива a. Рисунок ниже поможет вам понять ( _{прочитайте этот ответ для подробного объяснения} ):

Это поможет вам понять , что , почему aи &aимеет тот же адрес , и как (&a)[i]это адрес I - ^го массива (такого же размера, как уa ).

Итак, утверждение

return (&a)[n] - a; 

эквивалентно

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

и эта разница будет давать количество элементов между указателями (&a)[n]и (&a)[0], которые являются nмассивами каждого из n intэлементов. Следовательно, все элементы массива равны n*n= n² .

НОТА:

C11: 6.5.6 Аддитивные операторы (p9):

Когда вычтены два указателя, оба должны указывать на элементы одного и того же объекта массива или один после последнего элемента объекта массива ; Результатом является разница индексов двух элементов массива. Размер результата определяется реализацией , а его тип (целочисленный тип со знаком) ptrdiff_tопределяется в <stddef.h>заголовке. Если результат не может быть представлен в объекте этого типа, поведение не определено.

Поскольку (&a)[n]ни указатель на элементы одного и того же объекта массива, ни на один элемент после последнего элемента объекта массива (&a)[n] - aне вызовет неопределенное поведение .

Также отметим , что, лучше изменить тип возвращаемого значения функции pв ptrdiff_t.

a является (переменным) массивом n int .

&a указатель на (переменную) массив n int .

(&a)[1]это указатель на intодин intпосле последнего элемента массива. Этот указатель является n intэлементами после&a[0] .

(&a)[2]является указателем intодного intпоследнего элемента массива из двух массивов. Этот указатель является 2 * n intэлементами после&a[0] .

(&a)[n]является указателем на intодин intпосле последнего элемента массива nмассивов. Этот указатель является n * n intэлементами после &a[0]. Просто вычтите &a[0]или у aвас естьn .

Конечно, это технически неопределенное поведение, даже если оно работает на вашем компьютере, так как (&a)[n]не указывает внутри массива или после последнего элемента массива (как того требуют правила C арифметики указателей).

Если у вас есть два указателя, которые указывают на два элемента одного и того же массива, то его разность приведет к количеству элементов между этими указателями. Например, этот фрагмент кода выведет 2.

int a[10];

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

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

Теперь давайте рассмотрим выражение

(&a)[n] - a;

В этом выражении aимеет тип int *и указывает на его первый элемент.

Выражение &aимеет тип int ( * )[n]и указывает на первый ряд отображаемого двумерного массива. Его значение соответствует значению aразных типов.

( &a )[n]

является n-м элементом этого отображаемого двумерного массива и имеет тип, int[n]то есть это n-й ряд отображаемого массива. В выражении (&a)[n] - aон преобразуется в адрес своего первого элемента и имеет тип `int *.

Таким образом, между (&a)[n]и aесть n строк из n элементов. Так что разница будет равна 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

Таким образом,

1. тип (&a)[n]являетсяint[n]указатель
2. тип a İŞ intуказатель

Теперь выражение (&a)[n]-aвыполняет вычитание указателя:

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