Почему массивы C не могут иметь длину 0?

Стандарт C11 гласит, что массивы как размера, так и переменной длины «должны иметь значение больше нуля». Каково оправдание для того, чтобы не допустить длину 0?

Особенно для массивов переменной длины имеет смысл иметь размер ноль время от времени. Это также полезно для статических массивов, когда их размер взят из макроса или опции конфигурации сборки.

Интересно, что GCC (и clang) предоставляют расширения, которые допускают массивы нулевой длины. Java также допускает массивы нулевой длины.

Я хотел бы поспорить, что массивы C - это всего лишь указатели на начало выделенного фрагмента памяти. Наличие размера 0 будет означать, что у вас есть указатель на ... ничего? Вы не можете иметь ничего, поэтому пришлось бы выбирать какую-то произвольную вещь. Вы не можете использовать null, потому что тогда ваши массивы 0 будут выглядеть как нулевые указатели. И в этот момент каждая другая реализация выберет различное произвольное поведение, что приведет к хаосу.

Давайте посмотрим, как массив обычно располагается в памяти:

         +----+
arr[0] : |    |
         +----+
arr[1] : |    |
         +----+
arr[2] : |    |
         +----+
          ...
         +----+
arr[n] : |    |
         +----+

Обратите внимание, что не существует отдельного объекта с именем, arrкоторый хранит адрес первого элемента; когда в выражении появляется массив, C вычисляет адрес первого элемента по мере необходимости.

Итак, давайте думать об этом: массив 0-элемент не будет иметь не хранения отведенные для него, а это означает , что нет ничего , чтобы вычислить адрес массива из (иначе говоря, нет никакого отображения объекта для идентификатора). Это все равно что сказать: «Я хочу создать intпеременную, которая не занимает памяти». Это бессмысленная операция.

редактировать

Java-массивы полностью отличаются от массивов C и C ++; это не примитивный тип, а ссылочный тип, полученный из Object.

Редактировать ²

Точка, затронутая в комментариях ниже - ограничение «больше 0» применяется только к массивам, размер которых указан через константное выражение ; VLA может иметь длину 0. Объявление VLA с 0-значным непостоянным выражением не является нарушением ограничения, но оно вызывает неопределенное поведение.

Понятно, что VLA - это разные животные от обычных массивов , и их реализация может учитывать размер 0 . Они не могут быть объявлены staticили находятся в области видимости файла, потому что размер таких объектов должен быть известен до запуска программы.

Также ничего не стоит, что начиная с C11 реализации не обязаны поддерживать VLA.

Вы обычно хотели бы, чтобы ваш массив нулевого (фактически переменного) размера знал свой размер во время выполнения. Затем упакуйте это в a structи используйте элементы гибкого массива , например, например:

struct my_st {
   unsigned len;
   double flexarray[]; // of size len
};

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

Конечно, вы бы выделить:

 unsigned len = some_length_computation();
 struct my_st*p = malloc(sizeof(struct my_st)+len*sizeof(double));
 if (!p) { perror("malloc my_st"); exit(EXIT_FAILURE); };
 p->len = len;
 for (unsigned ix=0; ix<len; ix++)
    p->flexarray[ix] = log(3.0+(double)ix);

AFAIK, это было уже возможно в C99, и это очень полезно.

Кстати, гибких элементов массива не существует в C ++ (потому что было бы трудно определить, когда и как они должны быть построены и уничтожены). Смотрите, однако, будущее std :: dynarray

Если выражение type name[count]записано в какой-то функции, то вы указываете компилятору C выделить sizeof(type)*countбайты кадра стека и вычислить адрес первого элемента в массиве.

Если выражение type name[count]написано вне всех функций и структурирует определения, то вы указываете компилятору C выделить sizeof(type)*countбайты сегмента данных и вычислить адрес первого элемента в массиве.

nameна самом деле это константный объект, который хранит адрес первого элемента в массиве, и каждый объект, который хранит адрес какой-либо памяти, называется указателем, поэтому эту причину вы рассматриваете nameкак указатель, а не как массив. Обратите внимание, что массивы в C могут быть доступны только через указатели.

Если countэто константное выражение, которое оценивается как ноль, то вы указываете компилятору C выделить нулевые байты либо в кадре стека, либо в сегменте данных и вернуть адрес первого элемента в массиве, но проблема заключается в том, что первый элемент массива нулевой длины не существует, и вы не можете вычислить адрес чего-то, что не существует.

Это рационально, что элемента нет. count+1не существует в countмассиве с длинной длиной, так что это причина, по которой компилятор C запрещает определять массив нулевой длины как переменную внутри и снаружи функции, потому что в чем тогда содержимое name? Какой адрес nameхранит именно?

Если pуказатель, то выражение p[n]эквивалентно*(p + n)

Когда звездочка * в правом выражении является операцией разыменования указателя, что означает доступ к памяти, на которую указывает указатель, p + nили доступ к памяти, адрес которой хранится p + n, где p + nуказатель выражения, он берет адрес pи добавляет к этому адресу число, nумноженное на размер типа указателя p.

Можно ли добавить адрес и номер?

Да, это возможно, потому что адрес представляет собой целое число без знака, обычно представляемое в шестнадцатеричном формате.

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

Со времен первоначального C89, когда в стандарте C указывалось, что что-то имеет неопределенное поведение, это означало: «Делайте все, что сделает реализацию на конкретной целевой платформе наиболее подходящей для ее предполагаемого назначения». Авторы Стандарта не хотели пытаться угадать, какое поведение может быть наиболее подходящим для какой-либо конкретной цели. Существующие реализации C89 с расширениями VLA могли иметь разные, но логичные, поведения при заданном размере нуля (например, некоторые могли бы трактовать массив как выражение адреса, приводящее к NULL, в то время как другие рассматривали его как выражение адреса, которое могло бы равняться адресу другая произвольная переменная, но в нее можно было бы добавить ноль без перехвата). Если какой-либо код полагается на такое различное поведение, авторы Стандарта не

Вместо того, чтобы пытаться угадать, что могут делать реализации, или предлагать, чтобы какое-либо поведение считалось превосходящим любое другое, авторы Стандарта просто позволяли разработчикам использовать суждение при рассмотрении этого случая так, как им было удобно. Реализации, которые используют malloc () за кулисами, могут обрабатывать адрес массива как NULL (если нулевой размер malloc приводит к нулю), те, которые используют вычисления стекового адреса, могут давать указатель, который совпадает с адресом какой-либо другой переменной, и некоторые другие реализации могут делать другие вещи. Я не думаю, что они ожидали, что авторы компиляторов сделают все возможное, чтобы заставить случай с нулевым размером вести себя преднамеренно бесполезно.