«Int * nums = {5, 2, 1, 4}» вызывает ошибку сегментации

int *nums = {5, 2, 1, 4};
printf("%d\n", nums[0]);

вызывает segfault, тогда как

int nums[] = {5, 2, 1, 4};
printf("%d\n", nums[0]);

нет. В настоящее время:

int *nums = {5, 2, 1, 4};
printf("%d\n", nums);

печатает 5.

Основываясь на этом, я предположил, что обозначение инициализации массива, {}, слепо загружает эти данные в любую переменную слева. Когда это int [], массив заполняется по желанию. Когда это int *, указатель заполняется на 5, а ячейки памяти после того, где хранится указатель, заполняются на 2, 1 и 4. Таким образом, nums [0] пытается разыграть 5, вызывая segfault.

Если я ошибаюсь, поправьте меня. И если я прав, пожалуйста, уточните, потому что я не понимаю, почему инициализаторы массива работают так, как они.

В C есть (глупое) правило, согласно которому любая простая переменная может быть инициализирована с помощью списка инициализаторов, заключенного в фигурные скобки, как если бы это был массив.

Например, вы можете написать int x = {0};, что полностью эквивалентно int x = 0;.

Поэтому, когда вы пишете, int *nums = {5, 2, 1, 4};вы фактически даете список инициализаторов для одной переменной-указателя. Однако это всего лишь одна переменная, поэтому ей будет присвоено только первое значение 5, остальная часть списка игнорируется (на самом деле я не думаю, что код с избыточными инициализаторами должен даже компилироваться с помощью строгого компилятора) - он не вообще записываются в память. Код эквивалентен int *nums = 5;. Это означает, что он numsдолжен указывать на адрес 5 .

На этом этапе вы уже должны были получить два предупреждения / ошибки компилятора:

• Назначение целого числа указателю без приведения.
• Лишние элементы в списке инициализаторов.

И тогда, конечно, код выйдет из строя и сгорит, поскольку 5, скорее всего, это неверный адрес, с которым вам разрешено разыменовать nums[0].

В качестве побочного примечания вы должны printfуказывать адреса с помощью %pспецификатора, иначе вы вызовете неопределенное поведение.

Я не совсем уверен, что вы здесь пытаетесь сделать, но если вы хотите установить указатель, указывающий на массив, вы должны сделать:

int nums[] = {5, 2, 1, 4};
int* ptr = nums;

// or equivalent:
int* ptr = (int[]){5, 2, 1, 4};

Или, если вы хотите создать массив указателей:

int* ptr[] = { /* whatever makes sense here */ };

РЕДАКТИРОВАТЬ

После некоторого исследования я могу сказать, что «список инициализаторов лишних элементов» действительно недействителен C - это расширение GCC .

Стандартная инициализация 6.7.9 говорит (выделено мной):

2 Ни один инициализатор не должен пытаться предоставить значение для объекта, не содержащегося в инициализируемом объекте.

/ - /

11 Инициализатор скаляра должен быть единственным выражением, необязательно заключенным в фигурные скобки. Начальным значением объекта является значение выражения (после преобразования); применяются те же ограничения типов и преобразования, что и для простого присваивания, при этом тип скаляра принимается как неквалифицированная версия его объявленного типа.

«Скалярный тип» - это стандартный термин, относящийся к одиночным переменным, которые не относятся к типу массива, структуры или объединения (они называются «агрегатным типом»).

Таким образом, на простом английском языке стандарт гласит: «когда вы инициализируете переменную, не стесняйтесь вставлять дополнительные фигурные скобки вокруг выражения инициализатора просто потому, что вы можете».

СЦЕНАРИЙ 1

int *nums = {5, 2, 1, 4};    // <-- assign multiple values to a pointer variable
printf("%d\n", nums[0]);    // segfault

Почему это один segfault?

Вы объявили numsкак указатель на int - numsон должен хранить в памяти адрес одного целого числа.

Затем вы попытались инициализировать numsмассив из нескольких значений. Поэтому, если не вдаваться в подробности, это концептуально неверно - бессмысленно назначать несколько значений переменной, которая должна содержать одно значение. В этом отношении вы увидите точно такой же эффект, если сделаете это:

int nums = {5, 2, 1, 4};    // <-- assign multiple values to an int variable
printf("%d\n", nums);    // also print 5

В любом случае (назначьте несколько значений указателю или переменной типа int), тогда произойдет то, что переменная получит первое значение, которое 5 , а остальные значения игнорируются. Этот код соответствует требованиям, но вы получите предупреждения для каждого дополнительного значения, которого не должно быть в назначении:

warning: excess elements in scalar initializer.

В случае присвоения нескольких значений переменной-указателю, программа перестает работать при доступе nums[0], что означает, что вы буквально отсылаете все, что хранится по адресу 5 . В этом случае вы не выделили допустимую память для указателя nums.

Стоит отметить, что для случая присвоения нескольких значений переменной int нет segfault (здесь вы не разыменовываете какой-либо недопустимый указатель).

СЦЕНАРИЙ 2

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

Это не segfault, потому что вы на законных основаниях размещаете в стеке массив из 4 целых чисел.

СЦЕНАРИЙ 3

int *nums = {5, 2, 1, 4};
printf("%d\n", nums);   // print 5

Это не segfault, как ожидалось, потому что вы печатаете значение самого указателя - НЕ то, что он разыменовывает (что является недопустимым доступом к памяти).

Другие

Он почти всегда обречен на segfault всякий раз, когда вы жестко кодируете значение указателя, подобного этому (потому что это задача операционной системы - определить, какой процесс может получить доступ к какой области памяти).

int *nums = 5;    // <-- segfault

Итак, практическое правило - всегда инициализировать указатель на адрес некоторой выделенной переменной, например:

int a;
int *nums = &a;

или же,

int a[] = {5, 2, 1, 4};
int *nums = a; 

int *nums = {5, 2, 1, 4};неправильно сформированный код. Существует расширение GCC, которое обрабатывает этот код так же, как:

int *nums = (int *)5;

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

Чтобы избежать такого поведения (или, по крайней мере, получить предупреждение), вы можете скомпилировать в стандартном режиме, например -std=c11 -pedantic.

Альтернативная форма действительного кода:

int *nums = (int[]){5, 2, 1, 4};

который указывает на изменяемый литерал той же продолжительности хранения, что и nums. Однако эта int nums[]версия обычно лучше, поскольку использует меньше памяти, и вы можете использовать ее sizeofдля определения длины массива.

int *nums = {5, 2, 1, 4};

numsуказатель типа int. Таким образом, вы должны указать на некоторую допустимую область памяти. num[0]вы пытаетесь разыменовать какую-то случайную ячейку памяти и, следовательно, ошибку сегментации.

Да, указатель имеет значение 5, и вы пытаетесь разыменовать его, что является неопределенным поведением в вашей системе. (Выглядит как5 это недопустимая ячейка памяти в вашей системе)

В то время как

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

- допустимое объявление, в котором вы говорите, numsчто это массив типа, intа память выделяется на основе количества элементов, переданных во время инициализации.

Назначив {5, 2, 1, 4}

int *nums = {5, 2, 1, 4};

вы назначаете 5 nums(после неявного преобразования типа из int в указатель на int). Отмена ссылки делает вызов доступа к ячейке памяти по адресу 0x5. Это может быть запрещено вашей программе.

Пытаться

printf("%p", (void *)nums);