Почему адрес массива равен его значению в C?

В следующем фрагменте кода значения указателя и адреса указателя отличаются, как и ожидалось.

Но значения массива и адреса не имеют!

Как это может быть?

Вывод

my_array = 0022FF00
&my_array = 0022FF00
pointer_to_array = 0022FF00
&pointer_to_array = 0022FEFC

#include <stdio.h>

int main()
{
  char my_array[100] = "some cool string";
  printf("my_array = %p\n", my_array);
  printf("&my_array = %p\n", &my_array);

  char *pointer_to_array = my_array;
  printf("pointer_to_array = %p\n", pointer_to_array);
  printf("&pointer_to_array = %p\n", &pointer_to_array);

  printf("Press ENTER to continue...\n");
  getchar();
  return 0;
}

Имя массива обычно вычисляется в адрес первого элемента массива, так arrayи &arrayимеет одинаковое значение (но различные типов, так array+1и &array+1будет не быть равными , если массив больше , чем 1 элемент длиной).

Есть два исключения к этому: когда имя массива является операндом sizeofили унарным &(адресом), имя относится к самому объекту массива. Таким образом, sizeof arrayвы получите размер в байтах всего массива, а не размер указателя.

Для массива, определенного как T array[size], он будет иметь тип T *. Когда / если вы увеличиваете его, вы переходите к следующему элементу в массиве.

&arrayвычисляется по тому же адресу, но с учетом того же определения создает указатель типа T(*)[size]- т. е. это указатель на массив, а не на один элемент. Если вы увеличите этот указатель, он добавит размер всего массива, а не размер одного элемента. Например, с таким кодом:

char array[16];
printf("%p\t%p", (void*)&array, (void*)(&array+1));

Мы можем ожидать, что второй указатель будет на 16 больше первого (потому что это массив из 16 символов). Поскольку% p обычно преобразует указатели в шестнадцатеричное, это может выглядеть примерно так:

0x12341000    0x12341010

Это потому, что имя массива ( my_array) отличается от указателя на массив. Это псевдоним адреса массива, а его адрес определяется как адрес самого массива.

Однако указатель является обычной переменной C в стеке. Таким образом, вы можете взять его адрес и получить другое значение от адреса, который он содержит внутри.

Я писал об этой теме здесь - пожалуйста, посмотрите.

В C, когда вы используете имя массива в выражении (включая передачу его в функцию), если только оно не является операндом &оператора address-of ( ) или sizeofоператора, оно распадается на указатель на свой первый элемент.

То есть в большинстве контекстов arrayэквивалентно &array[0]как по типу, так и по значению.

В вашем примере my_arrayимеет тип, char[100]который уменьшается до a, char*когда вы передаете его в printf.

&my_arrayимеет тип char (*)[100](указатель на массив из 100 char). Поскольку это операнд &, это один из случаев, когда my_arrayне сразу затухает указатель на его первый элемент.

Указатель на массив имеет то же значение адреса, что и указатель на первый элемент массива, поскольку объект массива представляет собой просто непрерывную последовательность его элементов, но указатель на массив имеет тип, отличный от указателя на элемент этот массив. Это важно, когда вы выполняете арифметику указателей для двух типов указателей.

pointer_to_arrayимеет тип char *- инициализируется, чтобы указывать на первый элемент массива, как это происходит my_arrayв выражении инициализатора, - и &pointer_to_array имеет тип char **(указатель на указатель на a char).

Из них: my_array(после распада на char*), &my_arrayи pointer_to_arrayвсе они указывают непосредственно на массив или на первый элемент массива и поэтому имеют одинаковое значение адреса.

Причину my_arrayи &my_arrayрезультат в одном и том же адресе можно легко понять, если взглянуть на структуру памяти массива.

Допустим, у вас есть массив из 10 символов (вместо 100 в вашем коде).

char my_array[10];

Память для my_arrayвыглядит примерно так:

+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
^
|
Address of my_array.

В C / C ++ массив распадается на указатель на первый элемент в выражении, таком как

printf("my_array = %p\n", my_array);

Если вы посмотрите, где находится первый элемент массива, вы увидите, что его адрес совпадает с адресом массива:

my_array[0]
|
v
+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
^
|
Address of my_array[0].

В языке программирования B, который был непосредственным предшественником C, указатели и целые числа были свободно взаимозаменяемыми. Система будет вести себя так, как будто вся память представляет собой гигантский массив. С каждым именем переменной связан либо глобальный, либо относящийся к стеку адрес, для каждого имени переменной единственное, что должен отслеживать компилятор, это глобальная или локальная переменная и его адрес относительно первой глобальной или локальной переменной. переменная.

Учитывая глобальное заявление , как i;[не было никакой необходимости указывать тип, так как все было целое / указатель] будет обрабатываться компилятором как: address_of_i = next_global++; memory[address_of_i] = 0;и заявление , как i++будет обрабатываться как: memory[address_of_i] = memory[address_of_i]+1;.

Декларация вроде arr[10];бы будет обработана как address_of_arr = next_global; memory[next_global] = next_global; next_global += 10;. Обратите внимание, что как только это объявление было обработано, компилятор мог сразу забыть о том, arrчто он является массивом . Заявление вроде arr[i]=6;бы будет обработано как memory[memory[address_of_a] + memory[address_of_i]] = 6;. Компилятору было бы все равно, arrпредставлены ли массив и iцелое число, или наоборот. Действительно, было бы все равно, если бы они были массивами или обоими целыми числами; он с удовольствием сгенерирует код, как описано, независимо от того, будет ли полученное поведение полезным.

Одна из целей языка программирования C состояла в том, чтобы быть в значительной степени совместимым с B. В B имя массива [называемое "вектором" в терминологии B] идентифицировало переменную, содержащую указатель, который первоначально был назначен для указания на к первому элементу выделения заданного размера, поэтому, если это имя появилось в списке аргументов для функции, функция получит указатель на вектор. Несмотря на то, что C добавил «реальные» типы массивов, чье имя было жестко связано с адресом выделения, а не с переменной-указателем, которая первоначально указывала бы на выделение, наличие массивов, разлагаемых на созданный указателями код, объявивший массив типа C, ведет себя идентично в код B, который объявил вектор, а затем никогда не изменял переменную, содержащую ее адрес.

На самом деле, &myarrayи myarrayоба являются базовым адресом.

Если вы хотите увидеть разницу вместо использования

printf("my_array = %p\n", my_array);
printf("my_array = %p\n", &my_array);

использование

printf("my_array = %s\n", my_array);
printf("my_array = %p\n", my_array);