“Int * nums = {5, 2, 1, 4}” спричиняє помилку сегментації

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

викликає сегментацію, тоді як

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, викликаючи сегментацію.

Якщо я помиляюся, будь ласка, виправте мене. І якщо я помиляюсь, будь ласка, уточніть, тому що я не розумію, чому ініціалізатори масивів працюють так, як вони.

У 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 не існує сегментатора (тут ви не відміняєте жодного недійсного вказівника).

СЦЕНАРІЙ 2

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

Цей не є сегментарним, оскільки ви легально виділяєте масив з 4-х дюймів у стеку.

СЦЕНАРІЙ 3

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

Цей параметр не виконується за замовчуванням, як очікувалося, оскільки ви друкуєте значення самого вказівника - НЕ те, що це розмежування (що є недійсним доступом до пам'яті).

Інші

Це майже завжди приречене на 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);