ทำไมดัชนีอาเรย์เชิงลบจึงสมเหตุสมผล

ฉันเจอประสบการณ์แปลก ๆ ในการเขียนโปรแกรม C พิจารณารหัสนี้:

int main(){
  int array1[6] = {0, 1, 2, 3, 4, 5};
  int array2[6] = {6, 7, 8, 9, 10, 11};

  printf("%d\n", array1[-1]);
  return 0;
}

เมื่อฉันรวบรวมและเรียกใช้สิ่งนี้ฉันจะไม่ได้รับข้อผิดพลาดหรือคำเตือนใด ๆ ดังที่วิทยากรของฉันกล่าวว่าดัชนีอาร์เรย์-1เข้าถึงตัวแปรอื่น ฉันยังสับสนอยู่ทำไมภาษาโปรแกรมโลกถึงมีความสามารถนี้ ฉันหมายความว่าทำไมอนุญาตให้ดัชนีอาเรย์เชิงลบ

การดำเนินการทำดัชนีอาร์เรย์a[i]ได้รับความหมายจากคุณสมบัติดังต่อไปนี้ของ C

1. ไวยากรณ์เทียบเท่ากับa[i] *(a + i)ดังนั้นมันจึงเป็นที่ถูกต้องที่จะพูดที่จะได้รับองค์ประกอบที่5[a] 5a

2. ชี้เลขคณิตกล่าวว่าได้รับการชี้pและจำนวนเต็มi, p + i ตัวชี้pขั้นสูงโดยi * sizeof(*p)ไบต์

3. ชื่อของอาร์เรย์aจะเปลี่ยนไปเป็นตัวชี้ไปยังองค์ประกอบที่ 0 อย่างรวดเร็วa

ผลการทำดัชนีอาเรย์เป็นกรณีพิเศษของการทำดัชนีชี้ ตั้งแต่ตัวชี้สามารถชี้ไปที่สถานที่ใด ๆ ภายในอาร์เรย์แสดงออกโดยพลการใด ๆ ที่มีลักษณะเหมือนp[-1]เป็นไม่ผิดโดยการตรวจสอบและเพื่อให้คอมไพเลอร์ไม่ได้ (ไม่สามารถ) พิจารณาการแสดงออกดังกล่าวทั้งหมดเป็นข้อผิดพลาด

ตัวอย่างของคุณa[-1]ที่aชื่อจริงของอาร์เรย์ไม่ถูกต้อง IIRC มันไม่ได้กำหนดถ้ามีค่าตัวชี้ที่มีความหมายซึ่งเป็นผลมาจากการแสดงออกa - 1ที่aรู้ว่าเป็นตัวชี้ไปยังองค์ประกอบที่ 0 ของอาร์เรย์ ดังนั้นคอมไพเลอร์ที่ฉลาดสามารถตรวจจับสิ่งนี้และตั้งค่าสถานะเป็นข้อผิดพลาด คอมไพเลอร์ตัวอื่นยังสามารถใช้งานร่วมกันได้ในขณะที่ให้คุณถ่ายภาพตัวเองโดยการให้พอยน์เตอร์ชี้ไปที่ช่องสแต็คแบบสุ่ม

คำตอบวิทยาศาสตร์คอมพิวเตอร์คือ:

• ใน C ตัว[]ดำเนินการถูกกำหนดบนพอยน์เตอร์ไม่ใช่อาร์เรย์ โดยเฉพาะอย่างยิ่งมันถูกกำหนดไว้ในแง่ของเลขคณิตตัวชี้และความไม่สอดคล้องของตัวชี้

• ใน C ตัวชี้เป็นนามธรรมสิ่งอันดับมีเงื่อนไขว่า(start, length, offset) 0 <= offset <= lengthเลขคณิตของตัวชี้ถูกยกขึ้นทางคณิตศาสตร์เป็นหลักในออฟเซ็ตโดยมีข้อแม้ว่าหากผลลัพธ์ของการดำเนินการละเมิดเงื่อนไขตัวชี้จะเป็นค่าที่ไม่ได้กำหนด De อ้างอิงตัวชี้เพิ่มข้อ จำกัด offset < lengthเพิ่มเติมที่

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

อาร์เรย์มีโครงสร้างแบบเรียบง่ายเป็นชิ้นส่วนของหน่วยความจำที่ต่อเนื่องกัน การเข้าถึงอาร์เรย์เช่น [i] จะถูกแปลงเป็นการเข้าถึงที่อยู่หน่วยความจำที่อยู่addressOf (a) + i รหัสa[-1]นี้เป็นที่เข้าใจได้อย่างสมบูรณ์แบบมันหมายถึงที่อยู่หนึ่งก่อนที่จะเริ่มต้นของอาร์เรย์

สิ่งนี้อาจดูบ้า แต่มีหลายสาเหตุที่ทำให้สิ่งนี้ได้รับอนุญาต:

• การตรวจสอบว่าดัชนี i ถึง [-] นั้นมีราคาแพงหรือไม่
• เทคนิคการเขียนโปรแกรมบางอย่างใช้ประโยชน์จากข้อเท็จจริงที่ a[-1]ถูกต้อง ตัวอย่างเช่นถ้าฉันรู้ว่าaไม่ใช่จุดเริ่มต้นของอาร์เรย์ แต่เป็นตัวชี้ไปที่กึ่งกลางของอาร์เรย์จากนั้นa[-1]ก็รับองค์ประกอบของอาร์เรย์ที่อยู่ทางด้านซ้ายของตัวชี้

ตามที่คำตอบอื่น ๆ อธิบายนี่คือพฤติกรรมที่ไม่ได้กำหนดใน C. พิจารณาว่า C ถูกกำหนด (และส่วนใหญ่จะใช้) เป็น "แอสเซมเบลอร์ระดับสูง" ผู้ใช้ C ให้ความสำคัญกับความเร็วที่ไม่ลดทอนลงและการตรวจสอบสิ่งที่รันไทม์นั้นส่วนใหญ่เป็นคำถามเพื่อประโยชน์ในการใช้งาน บางคนสร้างซีที่ดูไร้สาระสำหรับคน comming จากภาษาอื่น ๆ ให้ความรู้สึกที่สมบูรณ์แบบใน C a[-1]เช่นนี้ ใช่มันไม่สมเหตุสมผลเสมอไป (

หนึ่งสามารถใช้คุณสมบัติดังกล่าวเพื่อเขียนวิธีการจัดสรรหน่วยความจำที่เข้าถึงหน่วยความจำโดยตรง การใช้งานอย่างหนึ่งคือการตรวจสอบบล็อกหน่วยความจำก่อนหน้านี้โดยใช้ดัชนีอาเรย์เชิงลบเพื่อตรวจสอบว่าสามารถรวมสองบล็อกได้หรือไม่ ฉันใช้คุณสมบัตินี้เมื่อฉันพัฒนาตัวจัดการหน่วยความจำแบบไม่ลบเลือน

C ไม่ได้พิมพ์อย่างยิ่ง คอมไพเลอร์ C มาตรฐานจะไม่ตรวจสอบขอบเขตของอาร์เรย์ สิ่งอื่น ๆ ที่อาร์เรย์ใน C คืออะไร แต่บล็อกติดกันของหน่วยความจำและการสร้างดัชนีเริ่มต้นที่ 0 ดังนั้นดัชนี -1 a[0]เป็นที่ตั้งของสิ่งบิตรูปแบบก่อน

ภาษาอื่น ๆ ใช้ประโยชน์จากดัชนีลบในทางที่ดี ใน Python a[-1]จะส่งคืนองค์ประกอบสุดท้ายจะส่งคืนองค์ประกอบa[-2]ที่สองไปยังอีกต่อไปและอื่น ๆ

ในคำง่าย ๆ :

ตัวแปรทั้งหมด (รวมถึงอาร์เรย์) ใน C จะถูกเก็บไว้ในหน่วยความจำ สมมติว่าคุณมี "หน่วยความจำ" 14 ไบต์และคุณเริ่มต้นต่อไปนี้:

int a=0;
int array1[6] = {0, 1, 2, 3, 4, 5};

นอกจากนี้ให้พิจารณาขนาดของ int เป็น 2 ไบต์ จากนั้นสมมุติว่าใน 2 ไบต์แรกของหน่วยความจำจำนวนเต็ม a จะถูกบันทึกไว้ใน 2 ไบต์ถัดไปจำนวนเต็มของตำแหน่งแรกของอาร์เรย์จะถูกบันทึกไว้ (นั่นหมายถึงอาร์เรย์ [0])

จากนั้นเมื่อคุณบอกว่าอาร์เรย์ [-1] เหมือนกับการอ้างถึงจำนวนเต็มที่บันทึกไว้ในหน่วยความจำซึ่งอยู่ก่อนอาร์เรย์ [0] ซึ่งในสมมุติฐานของเราคือจำนวนเต็ม a ในความเป็นจริงนี่ไม่ใช่วิธีที่ตัวแปรจัดเก็บในหน่วยความจำ

//:Example of negative index:
//:A memory pool with a heap and a stack:

unsigned char memory_pool[64] = {0};

unsigned char* stack = &( memory_pool[ 64 - 1] );
unsigned char* heap  = &( memory_pool[ 0     ] );

int stack_index =    0;
int  heap_index =    0;

//:reserve 4 bytes on stack:
stack_index += 4;

//:reserve 8 bytes on heap:
heap_index  += 8;

//:Read back all reserved memory from stack:
for( int i = 0; i < stack_index; i++ ){
    unsigned char c = stack[ 0 - i ];
    //:do something with c
};;
//:Read back all reserved memory from heap:
for( int i = 0; i < heap_index; i++ ){
    unsigned char c = heap[ 0 + i ];
    //:do something with c
};;