Что произойдет, если я определю массив нулевого размера в C / C ++?

Просто любопытно, что на самом деле произойдет, если я определю int array[0];в коде массив нулевой длины ? GCC вообще не жалуется.

Пример программы

#include <stdio.h>

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

осветление

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

Это потому, что мне нужно выпустить некоторый код в дикую природу, поэтому я пытаюсь выяснить, нужно ли мне обрабатывать случаи, когда SIZEопределяется как 0, что происходит в некотором коде со статически определеннымint array[SIZE];

Я был действительно удивлен, что GCC не жалуется, что привело к моему вопросу. Судя по полученным мной ответам, я считаю, что отсутствие предупреждения в значительной степени связано с поддержкой старого кода, который не был обновлен с использованием нового синтаксиса [].

Поскольку меня в основном интересовала ошибка, я помечаю ответ Lundin как правильный (Nawaz был первым, но он не был таким полным) - другие указывали на его фактическое использование для структур с подбитыми хвостами, хотя и актуально, не так ли? Это именно то, что я искал.

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

ISO 9899: 2011 6.7.6.2:

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

Приведенный выше текст верен как для простого массива (параграф 1). Для VLA (массива переменной длины) поведение не определено, если значение выражения меньше или равно нулю (параграф 5). Это нормативный текст в стандарте C. Компилятору не разрешается реализовывать это иначе.

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) или struct hack (спасибо Джо Врешнигу за указание на это).

Однако этот синтаксис был стандартизирован (и эффекты гарантированы) только недавно в C99. Раньше требовался постоянный размер.

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

Однако практика заполнения хвоста основана на том, что хранилище доступно (осторожно malloc), поэтому в целом не подходит для использования стека.

В Стандартных C и C ++ массив нулевого размера не допускается.

Если вы используете GCC, скомпилируйте его с помощью -pedanticoption. Он предупредит , говоря:

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 :

В 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 вы должны использовать гибкий член массива, который немного отличается по синтаксису и семантике:

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

Реальный пример - это массивы нулевой длины struct kdbus_itemв kdbus.h (модуль ядра Linux).

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

Взлом структуры, обычно реализуемый с использованием массива размером 1, является изворотливым, и я не думаю, что компиляторы должны воздерживаться от его нарушения. Например, я ожидал бы, что если компилятор увидит int a[1], он будет вправе рассматривать a[i]какa[0] . Если кто-то пытается обойти проблемы с выравниванием структуры взлома с помощью чего-то вроде

typedef struct {
  uint32_t size;
  uint8_t data [4]; // Используйте четыре, чтобы заполнение не уменьшало размер структуры
}

компилятор может сообразить и предположить, что размер массива действительно равен четырем:

; Как написано
  foo = myStruct-> data [я];
; В интерпретации (при условии, что аппаратное обеспечение с прямым порядком байтов)
  foo = ((* (uint32_t *) myStruct-> data) >> (i << 3)) & 0xFF;

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