จะเกิดอะไรขึ้นถ้าฉันกำหนดอาร์เรย์ขนาด 0 ใน C / C ++

แค่อยากรู้ว่าจะเกิดอะไรขึ้นถ้าฉันกำหนดอาร์เรย์ที่มีความยาวเป็นศูนย์int array[0];ในโค้ด? GCC ไม่บ่นเลย

โปรแกรมตัวอย่าง

#include <stdio.h>

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

การอธิบาย

ฉันกำลังพยายามหาว่าอาร์เรย์ที่มีความยาวเป็นศูนย์เริ่มต้นด้วยวิธีนี้แทนที่จะชี้ไปที่ความยาวตัวแปรในความคิดเห็นของ Darhazer นั้นได้รับการปรับให้เหมาะสมหรือไม่

นี่เป็นเพราะฉันต้องปล่อยโค้ดบางส่วนออกไปในป่าดังนั้นฉันจึงพยายามคิดว่าฉันต้องจัดการกับกรณีที่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) หรือแฮ็คโครงสร้าง (ขอบคุณ Joe Wreschnig ที่ชี้ให้เห็น)

อย่างไรก็ตามไวยากรณ์นี้เป็นมาตรฐาน (และรับประกันผลกระทบ) เมื่อเร็ว ๆ นี้ใน C99 ก่อนหน้านี้จำเป็นต้องมีขนาดคงที่

• 1 เป็นวิธีพกพาที่จะไปแม้ว่ามันจะค่อนข้างแปลก
• 0 แสดงเจตนาได้ดีกว่า แต่ไม่ถูกกฎหมายเท่าที่มาตรฐานเกี่ยวข้องและได้รับการสนับสนุนเป็นส่วนเสริมโดยคอมไพเลอร์บางตัว (รวมถึง gcc)

อย่างไรก็ตามแนวทางปฏิบัติในการเติมส่วนท้ายขึ้นอยู่กับความจริงที่ว่าพื้นที่เก็บข้อมูลมีอยู่ (ระวังmalloc) จึงไม่เหมาะกับการใช้งานแบบสแต็กโดยทั่วไป

ใน Standard C และ C ++ ไม่อนุญาตให้ใช้อาร์เรย์ขนาดศูนย์..

หากคุณใช้ GCC ให้รวบรวมด้วย-pedanticตัวเลือก มันจะเตือนโดยพูดว่า:

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

และบูม :-)

การใช้อาร์เรย์ที่มีความยาวเป็นศูนย์อีกวิธีหนึ่งคือการสร้างออบเจ็กต์ที่มีความยาวตัวแปร (pre-C99) อาร์เรย์ที่มีความยาวเป็นศูนย์แตกต่างจากอาร์เรย์แบบยืดหยุ่นซึ่งมี [] โดยไม่มี 0

ยกมาจากgcc doc :

อนุญาตให้ใช้อาร์เรย์ที่มีความยาวเป็นศูนย์ใน 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 คุณจะใช้สมาชิกอาร์เรย์ที่ยืดหยุ่นซึ่งแตกต่างกันเล็กน้อยในด้านไวยากรณ์และความหมาย:

• สมาชิกอาร์เรย์ที่ยืดหยุ่นถูกเขียนเป็นเนื้อหา [] โดยไม่มี 0
• สมาชิกอาร์เรย์ที่ยืดหยุ่นมีประเภทที่ไม่สมบูรณ์ดังนั้นจึงไม่สามารถใช้ตัวดำเนินการ sizeof ได้

ตัวอย่างในโลกแห่งความเป็นจริงคืออาร์เรย์ที่มีความยาวเป็นศูนย์ของstruct kdbus_itemในkdbus.h (โมดูลเคอร์เนลของ Linux)

การประกาศอาร์เรย์ขนาดศูนย์ภายในโครงสร้างจะมีประโยชน์หากได้รับอนุญาตและหากความหมายเป็นเช่นนั้น (1) จะบังคับให้มีการจัดตำแหน่ง แต่ไม่จัดสรรพื้นที่ใด ๆ และ (2) การจัดทำดัชนีอาร์เรย์จะถือว่าเป็นพฤติกรรมที่กำหนดไว้ใน กรณีที่ตัวชี้ผลลัพธ์จะอยู่ในบล็อกหน่วยความจำเดียวกันกับโครงสร้าง พฤติกรรมดังกล่าวไม่เคยได้รับอนุญาตจากมาตรฐาน C ใด ๆ แต่คอมไพเลอร์รุ่นเก่าบางตัวอนุญาตก่อนที่มันจะกลายเป็นมาตรฐานสำหรับคอมไพเลอร์ที่อนุญาตให้มีการประกาศอาร์เรย์ที่ไม่สมบูรณ์โดยใช้วงเล็บว่าง

แฮ็คโครงสร้างตามที่ใช้กันทั่วไปโดยใช้อาร์เรย์ขนาด 1 นั้นหลบหลีกและฉันไม่คิดว่ามีข้อกำหนดใด ๆ ที่คอมไพเลอร์จะละเว้นจากการทำลายมัน ยกตัวอย่างเช่นผมจะคาดหวังว่าถ้าคอมไพเลอร์เห็นint a[1]ก็จะเป็นภายในสิทธิในการเรื่องเป็นa[i] a[0]หากมีคนพยายามแก้ไขปัญหาการจัดตำแหน่งของการแฮ็กโครงสร้างผ่านทางไฟล์

typedef struct {
  ขนาด uint32_t;
  ข้อมูล uint8_t [4]; // ใช้สี่ตัวเพื่อหลีกเลี่ยงการเว้นช่องว่างในการทิ้งขนาดของโครงสร้าง
}

คอมไพเลอร์อาจฉลาดขึ้นและคิดว่าขนาดอาร์เรย์เป็นสี่:

; ตามที่เขียน
  foo = myStruct-> ข้อมูล [i];
; ตามที่ตีความ (สมมติว่าฮาร์ดแวร์น้อยที่สุด)
  foo = ((* (uint32_t *) myStruct-> ข้อมูล) >> (i << 3)) & 0xFF;

การเพิ่มประสิทธิภาพการดังกล่าวอาจจะเป็นที่เหมาะสมโดยเฉพาะอย่างยิ่งถ้าจะโหลดลงทะเบียนในการดำเนินงานเช่นเดียวกับmyStruct->data myStruct->sizeฉันไม่รู้ว่าไม่มีอะไรในมาตรฐานที่ห้ามการเพิ่มประสิทธิภาพดังกล่าวแม้ว่าแน่นอนว่ามันจะทำลายโค้ดใด ๆ ที่อาจคาดว่าจะเข้าถึงสิ่งต่างๆนอกเหนือจากองค์ประกอบที่สี่