Що станеться, якщо я визначу масив розміром 0 у C / C ++?

Цікаво, що насправді відбувається, якщо я визначу масив нульової довжини int array[0];в коді? GCC взагалі не скаржиться.

Зразок програми

#include <stdio.h>

int main() {
    int arr[0];
    return 0;
}

Уточнення

Я насправді намагаюся з’ясувати, чи ініціалізовані таким чином масиви нульової довжини, замість того, щоб вказувати, як змінна довжина в коментарях Дархазера, оптимізована чи ні.

Це тому, що я повинен випустити якийсь код у дикій природі, тому я намагаюся розібратися, чи потрібно мені обробляти випадки, коли значення SIZEвизначено як 0, що відбувається в якомусь коді зі статично визначенимint array[SIZE];

Я був фактично здивований, що GCC не скаржиться, що призвело до мого питання. З отриманих відповідей, я вважаю, що відсутність попередження багато в чому пояснюється підтримкою старого коду, який не оновлювався новим синтаксисом [].

Оскільки я в основному задався питанням про помилку, я відзначаю відповідь Лундіна як правильну (перший був у Наваза, але він був не настільки повний) - інші вказували на його фактичне використання для конструкцій, накладених на хвости, хоча це актуально, чи не так ' t саме те, що я шукав.

Масив не може мати нульовий розмір.

ISO 9899: 2011 6.7.6.2:

Якщо вираз є постійним виразом, він повинен мати значення, що перевищує нуль.

Наведений вище текст справедливий як для простого масиву (параграф 1). Для VLA (масив змінної довжини) поведінка не визначена, якщо значення виразу менше або дорівнює нулю (параграф 5). Це нормативний текст у стандарті С. Компілятору заборонено реалізувати його по-іншому.

gcc -std=c99 -pedantic подає попередження для випадку, що не стосується VLA.

Відповідно до стандарту, це не дозволяється.

Однак у компіляторах C існує така практика, що трактувати ці декларації як декларацію гнучкого члена масиву ( FAM ) :

C99 6.7.2.1, §16 : Окремий випадок останній елемент структури з більш ніж одним названим членом може мати неповний тип масиву; це називається гнучким членом масиву.

Стандартний синтаксис FAM:

struct Array {
  size_t size;
  int content[];
};

Ідея полягає в тому, щоб ви потім розподілили його так:

void foo(size_t x) {
  Array* array = malloc(sizeof(size_t) + x * sizeof(int));

  array->size = x;
  for (size_t i = 0; i != x; ++i) {
    array->content[i] = 0;
  }
}

Ви також можете використовувати його статично (розширення gcc):

Array a = { 3, { 1, 2, 3 } };

Це також відоме як підкладки з хвостами (цей термін передує публікації стандарту C99) або структура злому (спасибі Джо Врешнігу за те, що він це вказав).

Однак цей синтаксис був стандартизований (і ефекти гарантовані) лише останнім часом у С99. Перш ніж був необхідний постійний розмір.

• 1 Це був портативний шлях, хоча це було досить дивно.
• 0 було краще вказувати намір, але не є законним, що стосується Стандарту, і підтримується як розширення деякими компіляторами (включаючи gcc).

Однак практика прокладки хвоста покладається на той факт, що зберігання доступне (обережне malloc), тому воно не підходить для використання стека в цілому.

У стандартному C і C ++, масив нульового розміру НЕ допускається ..

Якщо ви використовуєте GCC, компілюйте його з -pedanticопцією. Це набере попередження , сказавши:

zero.c:3:6: warning: ISO C forbids zero-size array 'a' [-pedantic]

У випадку C ++ воно дає подібне попередження.

Це абсолютно незаконно і завжди було, але багато компіляторів нехтують сигналом про помилку. Я не впевнений, чому ти хочеш це робити. Я знаю одне використання - це викликати помилку часу компіляції з булева:

char someCondition[ condition ];

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

char someCondition[ 2 * condition - 1 ];

Це дає розмір 1 або -1, і я ніколи не знайшов компілятора, який би прийняв розмір -1.

Додам, що на цьому аргументі є ціла сторінка онлайн-документації gcc.

Деякі цитати:

Масиви нульової довжини дозволені в GNU C.

У ISO C90 вам слід надати вміст довжиною 1

і

Версії GCC до 3.0 дозволяли статично ініціалізувати масиви нульової довжини, як якщо б вони були гнучкими масивами. Окрім тих випадків, які були корисними, він також дозволяв ініціалізувати в ситуаціях, які могли б пошкодити пізніші дані

щоб ви могли

int arr[0] = { 1 };

і бум :-)

Ще одне використання масивів нульової довжини призначене для створення об'єкта змінної довжини (до-C99). Нульова довжина масиви є різними з гнучких масивів , які мають [] без 0.

Цитується з gcc doc :

Масиви нульової довжини дозволені в GNU C. Вони дуже корисні як останній елемент структури, який справді є заголовком для об'єкта змінної довжини:

 struct line {
   int length;
   char contents[0];
 };
 
 struct line *thisline = (struct line *)
   malloc (sizeof (struct line) + this_length);
 thisline->length = this_length;

В ISO C99 ви б використовували гнучкий елемент масиву, який дещо відрізняється за синтаксисом та семантикою:

• Члени гнучкого масиву записуються як вміст [] без 0.
• Члени гнучкого масиву мають неповний тип, тому оператор sizeof може не застосовуватися.

Прикладом реального світу є масиви нульової довжини struct kdbus_itemв kdbus.h (модуль ядра Linux).

Оголошення масиву нульового розміру в структурах були б корисні, якби вони були дозволені, і якби семантика була такою, що (1) вони примушували б вирівнювати, але в іншому випадку не виділяти жодного простору, і (2) індексація масиву вважатиметься визначеною поведінкою в випадок, коли отриманий вказівник знаходитиметься в тому ж блоці пам'яті, що і структура. Така поведінка ніколи не була дозволена жодним стандартом C, але деякі старі компілятори дозволяли це, перш ніж стало стандартним для компіляторів, допускати неповні декларації масиву з порожніми дужками.

Злом структури, як це зазвичай реалізується за допомогою масиву розміром 1, є хитрим, і я не думаю, що є жодна вимога, що компілятори утримуються від його порушення. Наприклад, я б очікувати , що якщо компілятор бачить int a[1], що це буде в межах своїх прав у відношенні a[i]як a[0]. Якщо хтось намагається вирішити проблеми з вирівнюванням зламаної структури через щось подібне

typedef structure {
  uint32_t розмір;
  дані uint8_t [4]; // Використовуйте чотири, щоб уникнути скидання накладки розміром структури
}

компілятор може стати розумним і припустити, що розмір масиву дійсно дорівнює чотирма:

; Як написано
  foo = myStruct-> дані [i];
; Як інтерпретується (якщо припустити, малоінтенсивне обладнання)
  foo = ((* (uint32_t *) myStruct-> дані) >> (i << 3)) & 0xFF;

Така оптимізація може бути розумною, особливо якщо вона myStruct->dataмогла бути завантажена в реєстр в тій же операції, що і myStruct->size. Я нічого не знаю в стандарті, який забороняв би таку оптимізацію, хоча, звичайно, він би порушив будь-який код, який, можливо, очікує доступу до матеріалів за межами четвертого елемента.