C / C ++ 'da 0 boyutlu bir dizi tanımlarsam ne olur?

Merak ediyorum, int array[0];kodda sıfır uzunluklu bir dizi tanımlarsam aslında ne olur ? GCC hiç şikayet etmiyor.

Örnek Program

#include <stdio.h>

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

açıklama

Aslında Darhazer'ın yorumlarındaki değişken uzunluk gibi işaret edilmek yerine sıfır uzunluklu dizilerin bu şekilde başlatılıp başlatılmadığını anlamaya çalışıyorum.

Bunun nedeni, bazı kodları vahşi doğada yayınlamam gerektiğidir, bu nedenle , statik olarak tanımlanmış bir kodla bazı kodlarda meydana gelen SIZE, olarak tanımlandığı durumlarla ilgilenmem gerekip gerekmediğini anlamaya çalışıyorum.0int array[SIZE];

Aslında GCC'nin şikayet etmemesine şaşırmıştım, bu da soruma yol açtı. Aldığım cevaplara göre, bir uyarının olmamasının büyük ölçüde yeni [] sözdizimi ile güncellenmemiş eski kodu desteklemesinden kaynaklandığına inanıyorum.

Esas olarak hatayı merak ettiğim için, Lundin'in cevabını doğru olarak etiketliyorum (Nawaz'ınki ilkti, ancak o kadar eksiksiz değildi) - diğerleri kuyruk dolgulu yapılar için gerçek kullanımına işaret ediyordu, ancak alakalı olsa da, değil '' t tam olarak aradığım şey.

Bir dizinin boyutu sıfır olamaz.

ISO 9899: 2011 6.7.6.2:

İfade sabit bir ifade ise, sıfırdan büyük bir değere sahip olmalıdır.

Yukarıdaki metin hem düz bir dizi için geçerlidir (1. paragraf). VLA (değişken uzunluk dizisi) için, ifadenin değeri sıfırdan küçük veya sıfıra eşitse davranış tanımsızdır (paragraf 5). Bu, C standardındaki normatif metindir. Bir derleyicinin onu farklı şekilde uygulamasına izin verilmez.

gcc -std=c99 -pedantic VLA olmayan durum için uyarı verir.

Standart gereği buna izin verilmez.

Bununla birlikte, bu bildirimleri esnek bir dizi üyesi ( FAM ) bildirimi olarak ele almak C derleyicilerinde mevcut uygulama olmuştur :

C99 6.7.2.1, §16 : Özel bir durum olarak, birden fazla adlandırılmış üyesi olan bir yapının son elemanı tamamlanmamış bir dizi türüne sahip olabilir; buna esnek dizi üyesi denir.

Bir FAM'in standart sözdizimi şöyledir:

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

Fikir, daha sonra onu şu şekilde tahsis etmenizdir:

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

Ayrıca statik olarak da kullanabilirsiniz (gcc uzantısı):

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

Bu aynı zamanda kuyruklu yapılar (bu terim C99 Standardının yayınlanmasından önce gelir) veya struct hack (bunu işaret ettiği için Joe Wreschnig'e teşekkürler ) olarak da bilinir .

Ancak bu sözdizimi yalnızca son zamanlarda C99'da standartlaştırıldı (ve etkiler garanti edildi). Önce sabit bir boyut gerekliydi.

• 1 oldukça tuhaf olmasına rağmen, taşınabilir bir yoldu.
• 0 amacı belirtmede daha iyiydi, ancak Standart söz konusu olduğunda yasal değildi ve bazı derleyiciler (gcc dahil) tarafından bir uzantı olarak desteklendi.

Bununla birlikte, kuyruk doldurma uygulaması, depolamanın mevcut olduğu gerçeğine dayanır (dikkatli malloc), bu nedenle genel olarak istif kullanımı için uygun değildir .

Standart C ve C ++, sıfır boyutlu dizi olduğu değil izin ..

GCC kullanıyorsanız, -pedanticseçeneği ile derleyin . Şunları söyleyerek uyarı verecektir :

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

C ++ olması durumunda benzer uyarı verir.

Bu tamamen yasa dışıdır ve her zaman öyledir, ancak birçok derleyici hatayı işaret etmeyi ihmal eder. Bunu neden yapmak istediğinden emin değilim. Bildiğim tek kullanım, bir boolean'dan bir derleme zamanı hatasını tetiklemektir:

char someCondition[ condition ];

Eğer conditionbir yanlış, o zaman ben bir derleme zamanı hatası alıyorum. Derleyiciler buna izin verdiğinden, ancak şunu kullanmaya başladım:

char someCondition[ 2 * condition - 1 ];

Bu 1 veya -1 boyutunu verir ve -1 boyutunu kabul edecek bir derleyici bulamadım.

Bu argümanda gcc'nin çevrimiçi dokümantasyonunun tam bir sayfası olduğunu ekleyeceğim .

Bazı alıntılar:

GNU C'de sıfır uzunluklu dizilere izin verilir.

ISO C90'da içeriklere 1 uzunluk vermeniz gerekir.

ve

3.0'dan önceki GCC sürümleri, sıfır uzunluklu dizilerin, esnek dizilermiş gibi statik olarak başlatılmasına izin verdi. Yararlı olan bu durumlara ek olarak, daha sonraki verileri bozacak durumlarda başlatmaya da izin verdi

yani yapabilirsin

int arr[0] = { 1 };

ve patlama :-)

Sıfır uzunluklu dizilerin başka bir kullanımı, değişken uzunluklu nesneler (C99 öncesi) yapmak içindir. Sıfır uzunlukta diziler olan farklı gelen esnek diziler [] 0 olmadan sahiptir.

Gcc doc'tan alıntı :

GNU C'de sıfır uzunluklu dizilere izin verilir. Değişken uzunluklu bir nesne için gerçekten başlık olan bir yapının son öğesi olarak çok kullanışlıdırlar:

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

ISO C99'da, sözdizimi ve anlambilim açısından biraz farklı olan esnek bir dizi üyesi kullanırsınız:

• Esnek dizi üyeleri, 0 olmadan içerik olarak [] yazılır.
• Esnek dizi üyeleri eksik türe sahip ve bu nedenle sizeof operatörü uygulanamayabilir.

Bir gerçek dünya örneği sıfır uzunlukta diziler ise struct kdbus_itemde kdbus.h (Linux kernel modülü).

Yapılar içindeki sıfır boyutlu dizi bildirimlerine izin verildiyse ve anlambilim böyle olsaydı (1) hizalamayı zorlayacaklar ancak başka türlü herhangi bir alan ayırmayacaklarsa ve (2) diziyi indekslemek, sonuçta ortaya çıkan göstericinin struct ile aynı bellek bloğu içinde olacağı durum. Bu tür bir davranışa hiçbir C standardı tarafından asla izin verilmedi, ancak bazı eski derleyiciler, derleyiciler için boş parantezlerle eksik dizi bildirimlerine izin vermesi için standart hale gelmeden önce buna izin verdi.

Genellikle boyut 1 dizisi kullanılarak uygulanan struct hack işlemi tehlikelidir ve derleyicilerin onu kırmaktan kaçınmaları için herhangi bir gereksinim olduğunu düşünmüyorum. Örneğin, ben bir derleyici görürse bu beklenir int a[1], bu konuda kendi hakları içinde olacaktır a[i]olarak a[0]. Birisi struct hack'in hizalama sorunları gibi bir şeyle çözmeye çalışırsa

typedef struct {
  uint32_t boyutu;
  uint8_t verileri [4]; // Dolgunun yapının boyutunu düşürmesini önlemek için dört kullanın
}

bir derleyici zeki olabilir ve dizi boyutunun gerçekten dört olduğunu varsayabilir:

; Yazıldığı gibi
  foo = myStruct-> veri [i];
; Yorumlandığı gibi (küçük endian donanımı varsayarsak)
  foo = ((* (uint32_t *) myStruct-> veri) >> (i << 3)) & 0xFF;

Böyle bir optimizasyon, özellikle myStruct->dataaynı işlemde bir kayıt listesine yüklenebiliyorsa makul olabilir myStruct->size. Standartta böyle bir optimizasyonu yasaklayacak hiçbir şey bilmiyorum, elbette dördüncü öğenin ötesindeki şeylere erişmeyi bekleyebilecek herhangi bir kodu kırabilir.