Я нашел функцию, которая вычисляет квадрат числа:
int p(int n) {
int a[n]; //works on C99 and above
return (&a)[n] - a;
}
Возвращает значение n2. Вопрос в том, как он это делает? После небольшого тестирования я обнаружил, что между (&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
(&a) как указатель на объект n*sizeof(int), когда n неизвестен во время компиляции. Раньше C был простым языком...
- person Floris; 08.01.2015
* в коде. Вы можете решить, что это значит. Это глупый вызов.
- person Mark Lakata; 09.01.2015
* имеет более одного значения в C. Вы должны специально указать оператор умножения. На первый взгляд я подумал, что вы говорите об операторе косвенности, но понял, когда перешел по ссылке.
- person haccks; 09.01.2015
Чтобы понять этот прием, сначала вам нужно понять разницу в указателях, т. е. что происходит, когда вычитаются два указателя, указывающие на элементы одного и того же массива?
Когда один указатель вычитается из другого, результатом является расстояние (измеряемое в элементах массива) между указателями. Итак, если p указывает на a[i], а q указывает на a[j], то p - q равно i - j.
При вычитании двух указателей оба должны указывать на элементы одного и того же объекта массива или один после последнего элемента объекта массива; результатом является разница индексов двух элементов массива. [...].
Другими словами, если выражения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 = n2.
ПРИМЕЧАНИЕ:
При вычитании двух указателей оба должны указывать на элементы одного и того же объекта массива или один после последнего элемента объекта массива; результатом является разница индексов двух элементов массива. Размер результата определяется реализацией, а его тип (целочисленный тип со знаком) определяется
ptrdiff_tв заголовке<stddef.h>. Если результат не может быть представлен в объекте этого типа, поведение не определено.
Поскольку (&a)[n] не указывает ни на элементы одного и того же объекта массива, ни на элемент, следующий за последним элементом объекта массива, (&a)[n] - a вызовет неопределенное поведение.
Также обратите внимание, что лучше изменить тип возвращаемого значения функции p на ptrdiff_t.
&a[k] — это адрес kго элемента массива a. Именно (&a)[k] всегда будет считаться адресом массива из k элементов. Итак, первый элемент находится в позиции a (или &a), второй — в позиции a + (количество элементов массива a, равное n)*(размер элемента массива) и так далее. И обратите внимание, что память для массивов переменной длины выделяется в стеке, а не в куче.
- person haccks; 08.01.2015
(&a)[n]-(&a)[0] правильным способом сделать это?
- person Floris; 08.01.2015
(&a)[n] нарушает стандартное правило: оба должны указывать на элементы одного и того же объекта массива или один после последнего элемента объекта массива. Вы можете сделать это правильно, изменив тело функции на return sizeof (char [n][n]);, как это предлагается в этот комментарий.
- person haccks; 08.01.2015
a[n-1]. a[n] - это один после последнего элемента массива. (&a)[1] - это указатель на последний элемент (массив из n int) массива.
- person haccks; 14.01.2015
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 арифметики указателей).
[n] объявляет массив, а массивы разлагаются на указатели. Три отдельно полезных вещи с таким последствием.
- person Tommy; 08.01.2015
(&a)[n] является типом int[n], а который выражается как int* из-за массивов, выражающихся как адрес их первого элемента, если это неясно в описании.
- person WhozCraig; 08.01.2015
Если у вас есть два указателя, которые указывают на два элемента одного и того же массива, то их разница даст количество элементов между этими указателями. Например, этот фрагмент кода выведет 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
Таким образом,
(&a)[n] - это указатель int[n]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
int p(n)? Это даже компилируется? - person barak manos schedule 08.01.2015gcc. - person lurker schedule 08.01.2015int q(int n) { return sizeof (char [n][n]); }- person ouah schedule 08.01.2015sizeofдля сохранения символов. Все остальные: это намеренно неясный код, это неопределенное поведение, ответ @ouah правильный. - person ecatmur schedule 08.01.2015O(n^2)для расчетаn^2- person Khaled.K schedule 14.01.2015