Co się stanie, jeśli zdefiniuję tablicę o rozmiarze 0 w C / C ++?

Ciekawe, co się właściwie stanie, jeśli zdefiniuję int array[0];w kodzie tablicę o zerowej długości ? GCC w ogóle nie narzeka.

Przykładowy program

#include <stdio.h>

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

Wyjaśnienie

Właściwie próbuję dowiedzieć się, czy tablice o zerowej długości zainicjowane w ten sposób, zamiast wskazywać na zmienną długość w komentarzach Darhazera, są zoptymalizowane, czy nie.

Dzieje się tak, ponieważ muszę wypuścić jakiś kod na wolność, więc próbuję dowiedzieć się, czy muszę obsługiwać przypadki, w których SIZEzdefiniowano jako 0, co zdarza się w niektórych kodzie ze zdefiniowanym statycznieint array[SIZE];

Zaskoczyło mnie, że GCC nie narzeka, co doprowadziło do mojego pytania. Z otrzymanych odpowiedzi wynika, że ​​brak ostrzeżenia jest w dużej mierze spowodowany obsługą starego kodu, który nie został zaktualizowany nową składnią [].

Ponieważ zastanawiałem się głównie nad błędem, oznaczam odpowiedź Lundina jako poprawną (odpowiedź Nawaza była pierwsza, ale nie była tak kompletna) - inni wskazywali jej faktyczne zastosowanie w konstrukcjach wyściełanych ogonem, chociaż istotne, nie jest dokładnie to, czego szukałem.

Tablica nie może mieć zerowego rozmiaru.

ISO 9899: 2011 6.7.6.2:

Jeżeli wyrażenie jest wyrażeniem stałym, powinno mieć wartość większą od zera.

Powyższy tekst jest prawdziwy zarówno dla zwykłej tablicy (akapit 1). W przypadku VLA (tablicy o zmiennej długości) zachowanie jest niezdefiniowane, jeśli wartość wyrażenia jest mniejsza lub równa zero (akapit 5). To jest tekst normatywny w standardzie C. Kompilator nie może zaimplementować go inaczej.

gcc -std=c99 -pedantic daje ostrzeżenie dla przypadku innego niż VLA.

Zgodnie ze standardem nie jest to dozwolone.

Jednak obecną praktyką w kompilatorach C jest traktowanie tych deklaracji jako deklaracji elastycznego elementu tablicy ( FAM ) :

C99 6.7.2.1, §16 : W szczególnym przypadku ostatni element struktury z więcej niż jednym nazwanym elementem może mieć niekompletny typ tablicy; nazywa się to elastycznym składnikiem tablicy.

Standardowa składnia FAM to:

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

Chodzi o to, że następnie przydzielisz go tak:

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;
  }
}

Możesz też użyć go statycznie (rozszerzenie gcc):

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

Jest to również znane jako struktury wyściełane ogonem (termin ten poprzedza publikację C99 Standard) lub struct hack (dzięki Joe Wreschnigowi za wskazanie tego).

Jednak ta składnia została ustandaryzowana (a efekty gwarantowane) dopiero niedawno w C99. Wcześniej stały rozmiar był konieczny.

• 1 był przenośny, choć był raczej dziwny.
• 0 był lepszy w wskazywaniu zamiaru, ale nie był zgodny z prawem, jeśli chodzi o Standard i był obsługiwany jako rozszerzenie przez niektóre kompilatory (w tym gcc).

Jednak praktyka wyściełania ogonem opiera się na fakcie, że miejsce do przechowywania jest dostępne (ostrożnie malloc), więc ogólnie nie nadaje się do używania w stosie.

W standardowym C i C ++ tablice o rozmiarze zerowym nie są dozwolone.

Jeśli używasz GCC, skompiluj go z -pedanticopcją. Daje ostrzeżenie , mówiąc:

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

W przypadku C ++ daje podobne ostrzeżenie.

Jest to całkowicie nielegalne i zawsze było, ale wielu kompilatorów zaniedbuje sygnalizowanie błędu. Nie wiem, dlaczego chcesz to zrobić. Jedynym zastosowaniem, o którym wiem, jest wywołanie błędu czasu kompilacji z wartości logicznej:

char someCondition[ condition ];

Jeśli conditionjest fałszem, pojawia się błąd czasu kompilacji. Ponieważ kompilatory na to pozwalają, postanowiłem użyć:

char someCondition[ 2 * condition - 1 ];

Daje to rozmiar 1 lub -1, a nigdy nie znalazłem kompilatora, który zaakceptowałby rozmiar -1.

Dodam, że na ten argument znajduje się cała strona dokumentacji online gcc.

Niektóre cytaty:

Tablice o zerowej długości są dozwolone w GNU C.

W ISO C90 musiałbyś podać zawartość o długości 1

i

Wersje GCC przed 3.0 umożliwiały statyczną inicjalizację tablic o zerowej długości, tak jakby były one elastycznymi tablicami. Oprócz przypadków, które były przydatne, pozwalał również na inicjalizacje w sytuacjach, które mogłyby uszkodzić późniejsze dane

więc możesz

int arr[0] = { 1 };

i bum :-)

Innym zastosowaniem tablic o zerowej długości jest tworzenie obiektów o zmiennej długości (przed C99). Macierze zerowej długości są różne od elastycznych tablic które [] Nie 0.

Cytat z dokumentu gcc :

Tablice o zerowej długości są dozwolone w GNU C. Są one bardzo przydatne jako ostatni element struktury, która jest tak naprawdę nagłówkiem obiektu o zmiennej długości:

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

W ISO C99 użyłbyś elastycznego elementu tablicy, który różni się nieco składnią i semantyką:

• Elastyczne elementy tablicy są zapisywane jako zawartość [] bez 0.
• Elastyczne elementy składowe tablicy mają niepełny typ, więc operator sizeof nie może być stosowany.

Rzeczywisty przykład to tablice o zerowej długości struct kdbus_itemw kdbus.h (moduł jądra Linuksa).

Deklaracje tablic o zerowym rozmiarze w strukturach byłyby przydatne, gdyby były dozwolone, a semantyka byłaby taka, że ​​(1) wymuszałyby wyrównanie, ale w przeciwnym razie nie przydzielałyby żadnej spacji, oraz (2) indeksowanie tablicy byłoby uważane za zdefiniowane zachowanie w przypadek, w którym wynikowy wskaźnik znajdowałby się w tym samym bloku pamięci co struktura. Takie zachowanie nigdy nie było dozwolone przez żaden standard C, ale niektóre starsze kompilatory zezwalały na to, zanim stało się standardem dla kompilatorów, zezwalając na niekompletne deklaracje tablic z pustymi nawiasami.

Struct hack, powszechnie implementowany przy użyciu tablicy o rozmiarze 1, jest podejrzany i nie sądzę, aby istniał żaden wymóg, aby kompilatory go powstrzymywały. Na przykład spodziewałbym się, że jeśli kompilator zobaczy int a[1], będzie miał prawo traktować go a[i]jako plik a[0]. Jeśli ktoś próbuje obejść problemy z wyrównaniem struktury, włamać się za pomocą czegoś takiego jak

typedef struct {
  rozmiar uint32_t;
  dane uint8_t [4]; // Użyj czterech, aby dopełnienie nie wpłynęło na rozmiar struktury
}

kompilator może sprytnie i założyć, że rozmiar tablicy naprawdę wynosi cztery:

; Tak jak napisane
  foo = myStruct-> data [i];
; Zgodnie z interpretacją (zakładając sprzęt little-endian)
  foo = ((* (uint32_t *) myStruct-> data) >> (i << 3)) & 0xFF;

Taka optymalizacja może być rozsądna, zwłaszcza jeśli myStruct->datamogłaby zostać załadowana do rejestru w tej samej operacji, co myStruct->size. W standardzie nie znam niczego, co zabraniałoby takiej optymalizacji, chociaż oczywiście złamałby każdy kod, który mógłby oczekiwać dostępu do rzeczy poza czwartym elementem.