Плутанина щодо ініціалізації масиву в C

На мові C, якщо ініціалізувати такий масив:

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

тоді всі елементи масиву, які явно не ініціалізовані, будуть ініціалізовані неявно нулями.

Але якщо я ініціалізую такий масив:

int a[5]={a[2]=1};

printf("%d %d %d %d %d\n", a[0], a[1],a[2], a[3], a[4]);

вихід:

1 0 1 0 0

Я не розумію, чому a[0]друкується 1замість 0? Це невизначена поведінка?

Примітка. Це питання було задано в інтерв'ю.

TL; DR: Я не думаю, що поведінка int a[5]={a[2]=1};чітко визначена, принаймні у С99.

Найсмішніша частина полягає в тому, що єдиний біт, який має для мене сенс, - це частина, про яку ви питаєте: a[0]встановлюється 1тому, що оператор присвоєння повертає значення, яке було призначено. Все інше незрозуміло.

Якщо код був int a[5] = { [2] = 1 }, все вже були б легко: Це призначений ініціалізатор установки a[2]для 1і всього іншого 0. Але у { a[2] = 1 }нас є не призначений ініціалізатор, що містить вираз призначення, і ми опускаємося в кролячій норі.

Ось що я знайшов поки:

• a повинна бути локальною змінною.

  6.7.8 Ініціалізація

  4. Усі вирази в ініціалізаторі для об'єкта, який має статичну тривалість зберігання, повинні бути постійними виразами або рядковими літералами.

  a[2] = 1не є постійним виразом, тому aповинен мати автоматичне зберігання.

• a знаходиться в області власного ініціалізації.

  6.2.1 Область дії ідентифікаторів

  7. Теги структури, об'єднання та перерахування мають область застосування, яка починається одразу після появи тегу в специфікаторі типу, який оголошує тег. Кожна константа нумерації має область застосування, яка починається одразу після появи її визначеного переліку в списку нумераторів. Будь-який інший ідентифікатор має сферу дії, яка починається одразу після заповнення його декларатора.

  Декларатор є a[5], тому змінні знаходяться в області власної ініціалізації.

• a живе у власній ініціалізації.

  6.2.4 Тривалість зберігання предметів

  4. Об'єкт, ідентифікатор якого оголошено без зв'язку та без специфікатора класу зберігання,static має автоматичну тривалість зберігання .

  5. Для такого об’єкта, який не має типу масиву змінної довжини, його термін експлуатації продовжується від вступу до блоку, з яким він пов'язаний, поки виконання цього блоку не закінчується жодним чином. (Введення вкладеного блоку або виклик функції призупиняється, але не закінчується, виконання поточного блоку.) Якщо блок вводиться рекурсивно, кожен раз створюється новий примірник об'єкта. Початкове значення об’єкта невизначене. Якщо для об'єкта вказана ініціалізація, вона виконується кожного разу, коли досягається декларація при виконанні блоку; в іншому випадку значення стає невизначеним із кожним досягненням декларації.

• Після цього є точка послідовності a[2]=1.

  6.8 Виписки та блоки

  4. Повний вираз є виразом , яке не є частиною іншого виразу або з опису. Кожне з наведених нижче є повним виразом: ініціалізатор ; вираз у висловлюванні виразу; керуючий вираз оператора вибору ( ifабо switch); керуючий вираз a whileабо doтвердження; кожен (необов’язковий) вираз forзаяви; (необов'язковий) вираз у returnвиписці. Кінець повного виразу - точка послідовності.

  Слід зазначити , що , наприклад , в int foo[] = { 1, 2, 3 }в { 1, 2, 3 }частині є дужка обгороджений список ініціалізаторів, кожен з яких має точку послідовності після нього.

• Ініціалізація виконується в порядку списку ініціалізатора.

  6.7.8 Ініціалізація

  17. Кожен список ініціалізаторів, що додається до дужок, має пов'язаний поточний об'єкт . Якщо ніяких позначень немає, підмекти поточного об'єкта ініціалізуються в порядку відповідно до типу поточного об'єкта: елементи масиву у порядку збільшення підпису, члени структури в порядку декларування та перший названий член об'єднання. [...]

   

  19. Ініціалізація відбуватиметься в порядку списку ініціалізаторів, кожен ініціалізатор надається для певного субоб'єкта, що перекриває будь-який раніше перерахований ініціалізатор для того ж субекта; всі суб’єкти, які не ініціалізовані явно, повинні бути ініціалізовані неявно такими ж, як об'єкти, які мають статичну тривалість зберігання.

• Однак вирази ініціалізатора не обов'язково оцінюються в порядку.

  6.7.8 Ініціалізація

  23. Порядок, в якому виникають будь-які побічні ефекти серед виразів списку ініціалізації, не визначено.

Однак це залишає без відповіді деякі питання:

• Чи є пункти послідовності навіть релевантними? Основне правило:

  6.5 Вирази

  2. Між попередньою та наступною точкою послідовності об’єкт повинен змінити його збережене значення щонайбільше одночасно оцінкою виразу . Крім того, попереднє значення зчитується лише для визначення значення, яке потрібно зберігати.

  a[2] = 1 є виразом, але ініціалізація - ні.

  Це трохи суперечить Додатку J:

  J.2 Невизначена поведінка

  • Між двома точками послідовності об'єкт змінюється більше одного разу або модифікується, і попереднє значення зчитується інше, ніж для визначення значення, яке потрібно зберігати (6.5).

  Додаток J говорить про будь-які зміни, а не лише про модифікації виразами. Але враховуючи, що додатки ненормативні, ми можемо це ігнорувати.

• Яким чином ініціалізація піддослідностей секвенується щодо виразів ініціалізатора? Чи оцінюються спочатку всі ініціалізатори (у певному порядку), потім ініціалізовані суб’єкти з результатами (у порядку списку ініціалізаторів)? Або їх можна переплутати?

Я думаю int a[5] = { a[2] = 1 }, що виконується так:

1. Зберігання для aвиділяється при введенні блоку, що містить його. Вміст не визначений на даний момент.
2. Виконується (тільки) ініціалізатор ( a[2] = 1), за яким слідує точка послідовності. Це зберігає 1в a[2]і повертається 1.
3. Це 1використовується для ініціалізації a[0](перший ініціалізатор ініціалізує перший субект).

Але тут речі стають нечіткими , так як інші елементи ( a[1], a[2], a[3], a[4]) повинні бути ініційовані 0, але не ясно , коли: Чи мають це станеться до a[2] = 1оцінюваного? Якщо так, a[2] = 1то "виграє" та перезапише a[2], але чи буде це призначення не визначеною поведінкою, оскільки між нульовою ініціалізацією та виразом присвоєння немає точки послідовності? Чи є точки послідовності навіть релевантними (див. Вище)? Або відбувається нульова ініціалізація після того, як всі ініціалізатори будуть оцінені? Якщо так, a[2]то в кінцевому підсумку має бути 0.

Оскільки стандарт C чітко не визначає, що тут відбувається, я вважаю, що поведінка не визначена (за пропуском).

Я не розумію, чому a[0]друкується 1замість 0?

Імовірно спочатку a[2]=1ініціалізується a[2], а результат вираження використовується для ініціалізації a[0].

Від N2176 (проект C17):

6.7.9 Ініціалізація

23. Оцінки виразів списку ініціалізації невизначено послідовно послідовно відносяться один до одного, тому порядок, в якому виникають будь-які побічні ефекти, не визначений. ¹⁵⁴⁾

Отже, здавалося б, вихід 1 0 0 0 0також був би можливим.

Висновок: Не пишіть ініціалізатори, які змінюють ініціалізовану змінну на льоту.

Я думаю, що стандарт C11 охоплює таку поведінку і каже, що результат не визначений , і я не думаю, що C18 вніс відповідні зміни в цій галузі.

Стандартну мову легко розібрати. Відповідний розділ стандарту - §6.7.9 Ініціалізація . Синтаксис задокументований як:

initializer:
                assignment-expression
                { initializer-list }
                { initializer-list , }
initializer-list:
                designationopt initializer
                initializer-list , designationopt initializer
designation:
                designator-list =
designator-list:
                designator
                designator-list designator
designator:
                [ constant-expression ]
                . identifier

Зауважимо, що одним із термінів є присвоєння-вираз , а оскільки a[2] = 1це невід'ємно вираження присвоєння, воно допускається всередині ініціалізаторів для масивів з нестатичною тривалістю:

§4 Усі вирази в ініціалізаторі для об'єкта, який має статичну тривалість або тривалість зберігання, повинні бути постійними виразами або рядковими буквами.

Одним із ключових пунктів є:

§19 Ініціалізація має відбуватися в порядку списку ініціалізаторів, кожен ініціалізатор передбачає певний суб'єкт, що перекриває будь-який раніше перерахований ініціалізатор для того ж субекта; ¹⁵¹⁾ усі суб’єкти, які не ініціалізовані явно, повинні бути ініціалізовані неявно такими ж, як об'єкти, які мають статичну тривалість зберігання.

¹⁵¹⁾ Будь-який ініціалізатор для субоб'єкта, який переосмислюється, і таким чином не використовується для ініціалізації того, що суб'єкт може взагалі не оцінюватися.

І ще один ключовий параграф:

§23 Оцінки виразів списку ініціалізації невизначено послідовно послідовно відносяться один до одного, тому порядок, у якому виникають будь-які побічні ефекти, не визначений. ¹⁵²⁾

¹⁵²⁾ Зокрема, порядок оцінювання не повинен бути таким, як порядок ініціалізації субопредметів.

Я досить впевнений, що абзац §23 вказує на те, що позначення у питанні:

int a[5] = { a[2] = 1 };

призводить до невказаної поведінки. Присвоєння to a[2]є побічним ефектом, і порядок оцінки виразів невизначено послідовно послідовно взаємопов'язаний один з одним. Отже, я не думаю, що існує спосіб звернутися до стандарту і стверджувати, що певний компілятор обробляє це правильно чи неправильно.

Моє розуміння - це a[2]=1значення, яке повертає 1, тому код стає

int a[5]={a[2]=1} --> int a[5]={1}

int a[5]={1}призначити значення для [0] = 1

Звідси друкується 1 для [0]

Наприклад

char str[10]={‘H’,‘a’,‘i’};


char str[0] = ‘H’;
char str[1] = ‘a’;
char str[2] = ‘i;

Я намагаюся дати коротку і просту відповідь на головоломку: int a[5] = { a[2] = 1 };

1. Спочатку a[2] = 1встановлюється. Це означає, що масив говорить:0 0 1 0 0
2. Але ось, враховуючи, що ви зробили це в { }дужках, які використовуються для ініціалізації масиву по порядку, воно приймає перше значення (яке є 1) і встановлює це a[0]. Це як int a[5] = { a[2] };би залишилося там, де ми вже потрапили a[2] = 1. Тепер отриманий масив:1 0 1 0 0

Інший приклад: int a[6] = { a[3] = 1, a[4] = 2, a[5] = 3 };- Хоча порядок дещо довільний, якщо припустити, що він йде зліва направо, він би пройшов через ці 6 кроків:

0 0 0 1 0 0
1 0 0 1 0 0
1 0 0 1 2 0
1 2 0 1 2 0
1 2 0 1 2 3
1 2 3 1 2 3

Призначення a[2]= 1- це вираження, яке має значення 1, і ви, по суті, написали int a[5]= { 1 };(з побічним ефектом, який a[2]також призначається 1).

Я вірю, що int a[5]={ a[2]=1 }; це хороший приклад для програміста, який стріляє в свою ногу.

Я міг би спокуситись думати, що це ви мали на увазі int a[5]={ [2]=1 }; що було б позначений С99 елемент налаштування ініціалізатора 2 до 1, а решта - до нуля.

У рідкісному випадку, який ви насправді мали на увазі int a[5]={ 1 }; a[2]=1;, тоді це був би смішний спосіб його написання. Так чи інакше, до цього зводиться ваш код, навіть хоча деякі з них вказували, що він недостатньо чітко визначений, коли записування в a[2]насправді виконується. Проблема тут полягає в тому, що a[2]=1це не призначений ініціалізатор, а проста задача, яка сама має значення 1.