Имя массива это адрес первого элемента или указатель на его первый элемент в Си?

Question

[AslHack]

Есть код:

int arrOne[5] = {1,2,3,4,5};

Тут arrOne это адрес его первого элемента? Или указатель на его первый элемент? Или в указатель он превращается только когда это нужно (к примеру в арифметике адресов)? Или оба варианта верны?

Немного другая тема:

int arrTwo[3][2] = {{1,2}, {3,4}, {5,6}};

А с двумерным массивом как? Тут arrTwo это адрес первого элемента или указатель на его первый элемент т.е {1,2}? И получается arrTwo это адрес самого первого элемента {1,2} или же адрес первого элемента первого подмассива т.е {1}?

Comments

[res2001]

Имя массива - это адрес начала массива. Тип статического массива - это массив, а не тип его первого элемента, поэтому и имя рассматривается как адрес начала массива.
С двумерным массивом все работает аналогично. Имя двумерного массива - это адрес начала всего двумерного массива.
Напишите тест где выводите sizeof(arrOne) и sizeof(arrTwo) и разные другие варианты, которые придут в голову. Это даст понимание того, как компилятор воспринимает имя массива.

Answer 1

[Wataru]

arrOne и arrTwo - это переменные, типов int[5] и int[3][2]. Это на уровне C. Под капотом там указатели: компилятор знает адрес начала массива. Путаницу может вызвать то, что массивы в языке C тождественны указателям на начало с той лишь разницей, что компилятор знает его длину и всякие sizeof() сработают правильно.
Соответственно, arrOne неявно приводится к int*, а arrTwo к int (*)[2] (указатель на массив из 2 элементов, что в свою очередь неявно приводиться к указателю на указатель на инт).

Поэтому работает код:

int a[3][2];
   int (*b)[2];
   b = a;

Можно считать, что arrOne - указатель на первый элемент int, а arrTwo - указатель на первую строку int[2], по совместительству на первый элемент в первой строке:

int x = *arrOne;
   int y = **arrTwo; // с одной * не сработает ибо int[2], оно же int* к int не приводиться.
   int *z = arrOne+2; // указатель на 3-ий элемент
   int *w = arrTwo + 1; // указатель на вторую строку (первый элемент в ней).

Но лучше на закапываться в адрессную арифметику, а воспринимать массивы, как свой отдельный тип данных. Не пишите arrOne+1, а пишите arrOne[1] и не парьтесь.

Даже для int переменных компилятор знает их адрес, так что там под капотом тоже есть указатель. Не очень большая разница.

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

Comments

[jcmvbkbc]

Путаницу может вызвать то, что массивы в языке C тождественны указателям

Это не так, в чём легко убедиться:

#include <stdio.h>
int main()
{
    int a[4] = {1,2,3,4};
    int *p = a;

    printf("%p, %p\n", a, &a);
    printf("%p, %p\n", p, &p);
}

Выод для массива и для указателя разный.

[Wataru]

jcmvbkbc, А вот в этой программе - одинаковый:

#include <stdio.h>
int main()
{
    int a[4] = {1,2,3,4};
    int *p = (int*)&p;

    printf("%p, %p\n", a, &a);
    printf("%p, %p\n", p, &p);
}

Каждая переменная выводит свой адрес два раза.

А вот в этой программе a1 и a2 выводят разное, это значит по вашему, что эти 2 указателья ведут себя по разному?

#include <stdio.h>
int main()
{
    int *a1 = (int*)&a1;
    int *a2 = a1;

    printf("%p, %p\n", a1, &a1);
    printf("%p, %p\n", a2, &a2);
}

Да, он не совсем идентичен указателю. Наверное я не очень точно выразился. Но оно к нему приводится во многих контекстах.

[jcmvbkbc]

Да, он не совсем идентичен указателю

И уж совсем не тождественен. Это я и хотел сказать.

[jcmvbkbc]

Каждая переменная выводит свой адрес два раза.

Wataru, в моём примере для массива выводится дважды один и тот же адрес, а для указателя -- два разных -- адрес на который указатель указывает и адрес, в котором указатель хранится.
А в твоём -- выводятся одинаковые значения, но содержимое "массива" p -- не такое как у массива a.

[AslHack]

jcmvbkbc, а в указателе, который хранит адрес, вы когда ввели адрес самого указателя он же вроде не причем к самому массиву, у него же свой адрес в памяти ?

[AslHack]

Wataru, смотрите если вот это мне объясните я уже все пойму:

int zippo[4][2] = { {2, 4}, {6, 8}, {1, 3}, {5, 7}};

printf("zippo = %p, zippo + 1 = %p\n",
				zippo, zippo + 1);

printf("zippo[0] = %p, zippo[0] + 1 = %p\n",
                               zippo[0], zippo[0] + 1);
		
printf("*zippo = %p, *zippo + 1 = %p\n",
			      *zippo, *zippo + 1);

Смотрите что я понимаю:
zippo - адрес первого элемента т.е {2, 4} (ещё почему-то я думаю что это так же адрес первого элемента первого подмассива (первой строки) т.е 2)
zippo[0] - это адрес первого элемента в подмассиве ({2, 4}) т.е 2
*zippo - это получается мы получаем значение первого элемента массива, а первый элемент массива это же {2, 4}. Т.е хотел получить значение, а там не значение а адрес двойки?
И если хочу получить значение этой двойки то нужно сделать, получаются такие шаги:
*zippo = тут мы получили адрес первого элемента, первого подмассива zippo[0] или (&zippo[0][0]) И если хотим уже получить значение то нужно сделать так: *&zippo[0][0] или же **zippo

Вот то что я написал, я хоть что-то верно написал ?

[Wataru]

> ещё почему-то я думаю что это так же адрес первого элемента первого подмассива (первой строки) т.е 2)

А адреса совпадают. Ведь строка в памяти идет подряд и указатель на начало строки - хранит тот же адрес, что и указатель на первый элемент второй строки. Но надо помнить, что у него тип "указаель на массив". Соответственно, адрессная арифметика будет при +1 прибавлять размер строки, а не одного элемента.

Вы путаетесь, zippo - это указатель на int[2]. Адрес первой строки. zippo[0] - это взять первый элемент массива, т.е. строку. Т.е. вы получили указатель на первый элемент строки. Чтобы получить двойку надо этот указатель разименовать дописав [0]. Еще можно было бы сделать **zippo.

Но, чтобы получать элемент вам лучше индексировать массив. zippo[1][1] - второй элемент во второй строке. zippo[0][0] - это двойка. Не надо пытаться в адрессную арифметику и прибавлять числа к zippo или *zippo. Запутаетесь только и пользы никакой не извлечете.

[res2001]

Увлекательная беседа :)
AslHack,
zippo - адрес всего массива zippo[4][2], тип int[4][2];
zippo[0] - адрес первой строки массива zippo, тип int[2];
*zippo - то же, что и zippo[0]

Учитывая, что значения адреса для zippo, zippo[0], *zippo, zippo[0][0] - одно и то же, то это может вводить в заблуждение. Поэтому вывод вашего последнего теста надо рассматривать совместно с типами, т.е. смотреть пару адрес и тип совместно - только тогда вы поймете, что думает о них компилятор.
Поскольку тип в строковом представлении получить в run-time проблематично, то можно вместо типа использовать результат sizeof и уже по этому значению определять тип элемента.

Проще всего, чтоб не делать ошибок, при работе со статическими массивами всегда работать с ними через индексацию, без адресной арифметики. И относится к имени массива именно как к массиву, а не как к его первому элементу (т.е. не употребляйте *zippo).

[AslHack]

Wataru, Я просто хочу это понять. Конечно лучше использовать [], но все же мне очень хочется это хотя бы понять.

[AslHack]

res2001, Я просто хочу это понять. Конечно лучше использовать [], но все же мне очень хочется это хотя бы понять.

[AslHack]

Wataru А то что я писал, это разве не верно ?
вы написали что "Вы путаетесь, zippo - это указатель на int[2]. Адрес первой строки. " И сказали что zippo это адрес первой строки, но так же я понимаю что zippo это "int (zippo *) ["

[AslHack]

Wataru то что я писал выше, это я полагался на эти строки:

ПРИМЕР:
int zippo[4][2];

[AslHack]

AslHack, и кстати на эту картинку:

я вижу что zippo[0] это первый элемент двумерного массива, который в себе содержит массива из 2 элементов и получается zippo[0] это адрес этого внутреннего массива?

[Wataru]

AslHack, Вы путались вот тут:

zippo[0] это адрес первого элемента в подмассиве ({2, 4}) т.е 2

.

Понятнее было бы с zippo[1]. zippo - это массив из строк. Значит zippo[1] - это вторая строка. Но строка -массив, а значит фактически это указатель на первый элемент второй строки.
zippo[0] - это адрес строки {2,4}. Да, он совпадает с адресом 2, потому что 2 лежит в строке в начале. Но это совпадение. У вас могла бы быть не строка, а какая-нибудь хитрая структура.

zippo - Это двумерный массив, те. фактически указател-на-указатель. Каждые [] и * уменьшают указательность. Каждые & - увеличивают.

[res2001]

AslHack, Немного добавил вывода в ваш тест
Посмотрите результат на годболте.
Полезно будет сравнить ошибки gcc и clang. Поведение clang по умолчанию более адекватное - он предупреждает про усечение размера результата в операции sizeof где в операнде была адресная арифметика.

Если со статическим массивом используется адресная арифметика, то происходит не явное преобразование имени массива в указатель на его первый элемент. Соответственно теряется информация о полном типе массива. Именно об этом предупреждает clang при компиляции (а gcc молчит как пратизан) и это хорошо видно в выводе sizeof.
То же самое происходит при передаче массива в функцию.

Т.е. zippo + 1 имеет тип int[2], а не int[4][2] как можно было бы предположить.

[AslHack]

Wataru, аа точно, все теперь понял, zippo[3] к примеру это не указатель на первый элемент в этом 3 элементе, т.е в этом подмассиве. (Ну как бы он совпадает, но все же). zippo[3] это указатель на эту саму. строку в этом 3 элементе, и ещё указатель на её первый элемент. Спасибо большое за объяснение!

[AslHack]

res2001, ага т.е вот тут

zippo = 0x7fff35f14010, zippo + 1 = 0x7fff35f14020 sizeof(zippo)=64 sizeof(zippo+1)=8

Видно что сам zippo полный массив 64 байта, и вот когда мы уже используем адресную арифметику к примеру zippo + 1, то и далее имя неявно преобразуется в указатель на его первый элемент ? Это вы хотели объяснить?

Answer 2

[GavriKos]

А чем по вашему адрес от указателя отличается?

Про размерности массив ответ простой - arrTwo - это начало массива, первый элемент, его адрес в памяти. А дальше работает адресная арифметика.

Comments

[AslHack]

Адрес от указателя ? -> адрес это цифры по которым хранится переменная, а указатель эти самые цифры хранит.

int arrTwo[3][2] = {{1,2}, {3,4}, {5,6}};
arrTwo - это начало массива т.е первый элемент (имеется ввиду что адрес, вот этого элемента {1,2}) или адрес элемента подмассива т.е {1} ?

[GavriKos]

AslHack, у вас массив интов же. Значит ЭЛЕМЕНТ массива - это 1. А не 1,2

адрес это цифры по которым хранится переменная, а указатель эти самые цифры хранит.

Звучит как масло маслянное, не находите? Вы же можете в консоль просто вывести значение arrOne. Там будет что то невразумительное - адрес начала.

[AslHack]

у вас массив интов же. Значит ЭЛЕМЕНТ массива - это 1. А не 1,2

int arrTwo[3][2] = {{1,2}, {3,4}, {5,6}};
А почему массив интов ? Если массив хранит не инты, а массивы (в которых уже инты)

Ну хорошо в консоль выведу значение arrOne, и получу что-то типо 23454323456 или (-2456748324), это если без %p, а с ним уже более менее красиво. И это будет адрес на начало массива, хорошо но это же просто адрес т.е, так, если вы скажите нет, то я не пойму почему?
А сам указатель же хранит уже адреса ? Нет?

int a = 5;
int * ptr_a = &a;

Тут у a есть адрес к примеру x0239462fff83 - и это же типо просто символы, а указатель эти самые символы хранит ?
Можете пожалуйста сказать в чем я ошибся ?

[GavriKos]

AslHack, Нет, элемент массива - инт. Вы это сами пишете при объявлении.

Адрес есть у всего. Если я правильно помню - то в случае массива переменная arr1 хранит адрес начала массива в памяти. Т.е. является указателем.

[AslHack]

int arrTwo[3][2] = {{1,2}, {3,4}, {5,6}};
т.е тут к примеру первый элемент массива это int?

[GavriKos]

AslHack, у вас ВСЕ элементы массива - это int. Потому что это массив интов. А не массив пар интов.

[jcmvbkbc]

GavriKos, в С и в C++ многомерные массивы -- это массивы массивов. Т.е. int arrTwo[3][2] = {{1,2}, {3,4}, {5,6}}; -- это массив из 3 элементов, каждый из которых -- массив из 2 int. Подробнее например здесь.

[GavriKos]

jcmvbkbc, arrTwo[0] что вернет? Массив?

[jcmvbkbc]

arrTwo[0] что вернет? Массив?

GavriKos, да. Подробнее об этом например: здесь.

[GavriKos]

jcmvbkbc, хм. Провел эксперимент, и похоже я не прав, да. ПОизучаю, спасибо.

int arrTwo[3][2] = {{1,2}, {3,4}, {5,6}};
    for (int i=0; i<6;i++)
        printf("%d\n", *arrTwo[i]);

Ожидал что за счет линейного расположения в памяти цикл все равно выведет все элементы.

[jcmvbkbc]

GavriKos, он бы вывел, если скобочки поставить: (*arrTwo)[i], но что со скобками, что без, этот код вызывает undefined behavior.

[AslHack]

jcmvbkbc, Привет! А можешь пожалуйста но мой вопрос ответить ?

[GavriKos]

jcmvbkbc, тооочно! Но тогда получается (*arrTwo)[0] вернет не массив? ;-) А все таки T - инт? Просто у меня видимо совпало что при UB вывод был похож на первые элементы внутренних массивов....

Ссылку вашу читал, не понял как ее привязать к вашим аргументам

[jcmvbkbc]

AslHack, вопрос по большому счёту не имеет смысла.
Конкретно: "массив" -- это один из способов порождения типов определённых языком. Имя массива -- это имя, не адрес, не указатель. Свойства его определены стандартом. Как переход от имени к адресу реализован -- дело компилятора. На этом языковая часть вопроса как будто исчерпана. Всё остальное -- детали реализации.

Обычные компиляторы обычно реализуют массивы достаточно эффективно, для N массивов на стеке не требуется N дополнительных указателей, их адреса могут быть выведены из одного адреса кадра стека, но информация о смещениях начал массивов относительно этого базового адреса всё равно есть в коде. Аналогично, массивы выделенные статически в сегменте данных имеют связанный с ними символ (в смысле ELF или PE, или другого исполняемого формата), а места кода которые ссылаются на данные таких массивов используют этот символ для вычисления адреса.

[jcmvbkbc]

тогда получается (*arrTwo)[0] вернет не массив?

GavriKos, ну разумеется. arrTwo -- массив, *arrTwo -- массив, **arrTwo -- уже не массив.

[Adamos]

jcmvbkbc, вот только в реализации никаких отдельных указателей arrTwo[0], arrTwo[1] - не существует.
Это все трюки компилятора над одним указателем на общую для массива область памяти и адресная арифметика: arrTwo[1] = *arrTwo + sizeof(int) * 2.
В отличие от std::vector< std::vectot< int > >, у которого реально в основном векторе лежат отдельные объекты.
Боюсь, ТС по вашему объяснению как раз что-то такое представит.

[jcmvbkbc]

вот только в реализации никаких отдельных указателей arrTwo[0], arrTwo[1] - не существует.

Adamos, я где-то написал что они существуют?

Боюсь, ТС по вашему объяснению как раз что-то такое представит.

Моё объяснение -- "Массив -- это отдельный способ порождения типов. Имя -- это имя. Адрес -- это детали реализации".
Но я побуду адвокатом дьявола и предложу представить что-то неортодоксальное, но в то же время не противоречащее стандарту. Если у вас получится -- оно может существовать.

Answer 3

[Григорий]

C Array в памяти выделяется одним сплошным массивом не зависимо от размерности. его при желании даже можно преобразовать в 1 мерный массив:

int arr2[3][2] = {{1,2},{3,4},{5,6}};
auto arr1 = reinterpret_cast<int(&)[6]>(arr2);

Answer 4

[Adamos]

Имя массива - это строка в коде программы, по которой компилятор определяет, что работает с вот этой конкретной областью памяти. Зная ее начальный адрес и применяя адресную арифметику для нахождения адреса хоть линейного, хоть двумерного элемента (там просто arr[x][y] превращается в начальный адрес + (x * второй размер массива + y) * размер переменной. Массивы в С - это всегда плоская область памяти, размерность существует только для программиста, для удобства).
Указатель - это и есть переменная, в которой хранится адрес другой переменной. Например, первого элемента массива. Объявление указателя вместо целого числа просто позволяет компилятору понять, что программист именно это и имел в виду, и не ругаться на подозрительные операции.

Answer 5

[mayton2019]

Если ты работаешь с С++ то тебе объективно лучше использовать векторы из std.
У них - больше смысловых возможностей и они безопаснее с точки зреня контроля над ресурсами.

Многомерный массив
int arrTwo[3][2] = {{1,2}, {3,4}, {5,6}};
в обоих языках эмулируется через массив массивов.

Но его имеет смысл использовать когда у тебя есть матрица где число элементов в строке "скачет".
Например так
{{2,3,5}, {,7,11}, {13}};
В этом случае использование такого зубчатого массива оправдано. Мы экономим ресурсы.
Это может быть полезно для микро-контроллеров например где память меряется килобайтами.

Если матрица - прямоугольная то ее можно просто "отобразить" на плоский массив.