Apa yang terjadi jika saya mendefinisikan array ukuran 0 di C / C ++?

Hanya ingin tahu, apa yang sebenarnya terjadi jika saya mendefinisikan array nol-panjang int array[0];dalam kode? GCC tidak mengeluh sama sekali.

Program Sampel

#include <stdio.h>

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

Klarifikasi

Saya benar-benar mencoba mencari tahu apakah array panjang nol diinisialisasi dengan cara ini, bukannya diarahkan seperti panjang variabel dalam komentar Darhazer, dioptimalkan atau tidak.

Ini karena saya harus merilis beberapa kode keluar ke alam, jadi saya mencoba mencari tahu apakah saya harus menangani kasus-kasus di mana SIZEdidefinisikan sebagai 0, yang terjadi dalam beberapa kode dengan yang didefinisikan secara statisint array[SIZE];

Saya sebenarnya terkejut bahwa GCC tidak mengeluh, yang menyebabkan pertanyaan saya. Dari jawaban yang saya terima, saya percaya kurangnya peringatan sebagian besar karena mendukung kode lama yang belum diperbarui dengan sintaks [] baru.

Karena saya terutama bertanya-tanya tentang kesalahan, saya menandai jawaban Lundin sebagai benar (Nawaz pertama, tetapi tidak lengkap) - yang lain menunjukkan penggunaannya yang sebenarnya untuk struktur berlapis ekor, sementara yang relevan, bukan t persis apa yang saya cari.

Array tidak boleh memiliki ukuran nol.

ISO 9899: 2011 6.7.6.2:

Jika ekspresi adalah ekspresi konstan, itu harus memiliki nilai lebih besar dari nol.

Teks di atas benar untuk array biasa (paragraf 1). Untuk VLA (array panjang variabel), perilaku tidak terdefinisi jika nilai ekspresi kurang dari atau sama dengan nol (paragraf 5). Ini adalah teks normatif dalam standar C. Kompiler tidak diizinkan untuk mengimplementasikannya secara berbeda.

gcc -std=c99 -pedantic memberikan peringatan untuk kasus non-VLA.

Sesuai standar, itu tidak diperbolehkan.

Namun sudah menjadi praktik saat ini dalam kompiler C untuk memperlakukan deklarasi tersebut sebagai deklarasi anggota array fleksibel ( FAM ) :

C99 6.7.2.1, §16 : Sebagai kasus khusus, elemen terakhir dari suatu struktur dengan lebih dari satu anggota bernama dapat memiliki tipe array yang tidak lengkap; ini disebut anggota array yang fleksibel.

Sintaks standar FAM adalah:

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

Idenya adalah Anda akan mengalokasikannya demikian:

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

Anda mungkin juga menggunakannya secara statis (ekstensi gcc):

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

Ini juga dikenal sebagai struktur berlapis-empuk (istilah ini ada sebelum penerbitan Standar C99) atau struct hack (terima kasih kepada Joe Wreschnig karena menunjukkannya).

Namun sintaks ini distandarisasi (dan efeknya dijamin) hanya belakangan ini di C99. Sebelum ukuran konstan diperlukan.

• 1 adalah cara portabel untuk pergi, meskipun agak aneh.
• 0 lebih baik dalam menunjukkan niat, tetapi tidak sah sejauh Standar terkait dan didukung sebagai perpanjangan oleh beberapa penyusun (termasuk gcc).

Praktik padding tail, bagaimanapun, bergantung pada kenyataan bahwa penyimpanan tersedia (hati-hati malloc) sehingga tidak cocok untuk menumpuk penggunaan secara umum.

Dalam Standar C dan C ++, array ukuran-nol tidak diperbolehkan ..

Jika Anda menggunakan GCC, kompilasi dengan -pedanticopsi. Ini akan memberi peringatan , mengatakan:

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

Dalam kasus C ++, ia memberikan peringatan serupa.

Benar-benar ilegal, dan selalu demikian, tetapi banyak penyusun mengabaikan sinyal kesalahan. Saya tidak yakin mengapa Anda ingin melakukan ini. Satu penggunaan yang saya tahu adalah untuk memicu kesalahan waktu kompilasi dari boolean:

char someCondition[ condition ];

Jika conditionsalah, maka saya mendapatkan kesalahan waktu kompilasi. Karena kompiler mengizinkan ini, saya menggunakan:

char someCondition[ 2 * condition - 1 ];

Ini memberikan ukuran 1 atau -1, dan saya tidak pernah menemukan kompiler yang akan menerima ukuran -1.

Saya akan menambahkan bahwa ada seluruh halaman dokumentasi online gcc pada argumen ini.

Beberapa kutipan:

Array tanpa panjang diizinkan dalam GNU C.

Di ISO C90, Anda harus memberi konten panjang 1

dan

Versi GCC sebelum 3.0 memungkinkan array nol-panjang untuk diinisialisasi secara statis, seolah-olah mereka array fleksibel. Selain kasus-kasus yang berguna, itu juga memungkinkan inisialisasi dalam situasi yang akan merusak data selanjutnya

jadi kamu bisa

int arr[0] = { 1 };

dan booming :-)

Penggunaan lain dari array panjang-nol adalah untuk membuat objek panjang variabel (pra-C99). Zero-panjang array yang berbeda dari array yang fleksibel yang memiliki [] tanpa 0.

Dikutip dari gcc doc :

Array panjang nol diizinkan di GNU C. Mereka sangat berguna sebagai elemen terakhir dari struktur yang benar-benar header untuk objek panjang variabel:

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

Dalam ISO C99, Anda akan menggunakan anggota array fleksibel, yang sedikit berbeda dalam sintaks dan semantik:

• Anggota array fleksibel ditulis sebagai konten [] tanpa 0.
• Anggota array fleksibel memiliki tipe yang tidak lengkap, sehingga ukuran operator mungkin tidak diterapkan.

Contoh dunia nyata adalah array panjang nol struct kdbus_itemdi kdbus.h (modul kernel Linux).

Deklarasi array ukuran-nol dalam struct akan berguna jika diizinkan, dan jika semantiknya sedemikian sehingga (1) mereka akan memaksa penyelarasan tetapi jika tidak mengalokasikan ruang apa pun, dan (2) mengindeks array akan dianggap perilaku yang didefinisikan dalam kasus di mana pointer yang dihasilkan akan berada dalam blok memori yang sama dengan struct. Perilaku seperti itu tidak pernah diizinkan oleh standar C apa pun, tetapi beberapa kompiler lama mengizinkannya sebelum menjadi standar bagi kompiler untuk memungkinkan deklarasi array tidak lengkap dengan kurung kosong.

Struct hack, seperti yang biasa diimplementasikan menggunakan array ukuran 1, adalah cerdik dan saya tidak berpikir ada persyaratan yang kompiler menahan diri dari melanggar itu. Sebagai contoh, saya akan berharap bahwa jika seorang kompiler melihat int a[1], itu akan menjadi haknya untuk menganggapnya a[i]sebagai a[0]. Jika seseorang mencoba mengatasi masalah penyelarasan struct hack melalui sesuatu seperti

typedef struct {
  ukuran uint32_t;
  data uint8_t [4]; // Gunakan empat, untuk menghindari agar padding tidak membuang ukuran struct
}

kompiler mungkin menjadi pintar dan menganggap ukuran array benar-benar empat:

; Seperti yang tertulis
  foo = myStruct-> data [i];
; Seperti yang ditafsirkan (dengan asumsi perangkat keras little-endian)
  foo = ((* (uint32_t *) myStruct-> data) >> (i << 3)) & 0xFF;

Optimalisasi semacam itu mungkin masuk akal, terutama jika myStruct->datadapat dimuat ke dalam register dalam operasi yang sama dengan myStruct->size. Saya tidak tahu apa-apa dalam standar yang akan melarang optimasi seperti itu, meskipun tentu saja itu akan merusak kode apa pun yang mungkin berharap untuk mengakses barang-barang di luar elemen keempat.