ทำไมไวยากรณ์ C สำหรับอาร์เรย์พอยน์เตอร์และฟังก์ชั่นจึงถูกออกแบบด้วยวิธีนี้

หลังจากได้เห็น (และถาม!) คำถามมากมายคล้ายกับ

อะไรint (*f)(int (*a)[5])หมายถึงใน C?

และถึงแม้จะเห็นว่าพวกเขาสร้างโปรแกรมเพื่อช่วยให้ผู้คนเข้าใจไวยากรณ์ของ C ฉันก็อดไม่ได้ที่จะสงสัยว่า:

ทำไมไวยากรณ์ของ C จึงถูกออกแบบด้วยวิธีนี้

ตัวอย่างเช่นถ้าฉันออกแบบพอยน์เตอร์ฉันจะแปล "ตัวชี้ไปยังอาเรย์ของพอยน์เตอร์ 10 องค์ประกอบ" เป็น

int*[10]* p;

และไม่

int* (*p)[10];

ซึ่งฉันรู้สึกว่าคนส่วนใหญ่จะเห็นด้วยน้อยกว่ามาก

ดังนั้นฉันสงสัยว่าทำไมไวยากรณ์เอ่อไม่ได้ใช้งานง่าย? มีปัญหาเฉพาะหรือไม่ที่ไวยากรณ์แก้ปัญหา (อาจเป็นความกำกวม?) ที่ฉันไม่รู้?

ความเข้าใจของฉันเกี่ยวกับประวัติศาสตร์ของมันคือมันขึ้นอยู่กับสองประเด็นหลัก ...

ประการแรกผู้เขียนภาษาต้องการทำให้ไวยากรณ์เป็นศูนย์กลางมากกว่าที่จะพิมพ์เป็นศูนย์กลาง นั่นคือพวกเขาต้องการให้โปรแกรมเมอร์ดูการประกาศและคิดว่า "ถ้าฉันเขียนนิพจน์*func(arg)นั่นจะส่งผลให้intถ้าฉันเขียน*arg[N]ฉันจะมีการลอย" แทนที่จะ " funcต้องเป็นตัวชี้ไปยังฟังก์ชั่นนี้และคืนสิ่งนั้น "

รายการซีวิกิพีเดียบอกว่า:

แนวคิดของ Ritchie คือการประกาศตัวระบุในบริบทที่คล้ายคลึงกับการใช้งาน: "การประกาศสะท้อนการใช้งาน"

... อ้างถึง p122 ของ K & R2 ซึ่งอนิจจาฉันไม่ต้องไปหาใบเสนอราคาเพิ่มเติมสำหรับคุณ

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

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

ต้องบอกว่าฉันไม่ใช่ผู้เชี่ยวชาญด้านไวยากรณ์ภาษาหรือการเขียนคอมไพเลอร์ แต่ฉันรู้พอที่จะรู้ว่ามีอะไรให้รู้มากมาย)

ความแปลกประหลาดของภาษา C สามารถอธิบายได้ด้วยวิธีการทำงานของคอมพิวเตอร์เมื่อถูกออกแบบมา มีหน่วยความจำในการเก็บข้อมูลจำนวน จำกัด ดังนั้นมันสำคัญมากที่จะลดขนาดของไฟล์ซอร์สโค้ดเอง การฝึกการเขียนโปรแกรมย้อนกลับไปในยุค 70 และ 80 คือเพื่อให้แน่ใจว่าซอร์สโค้ดมีอักขระไม่กี่ตัวที่เป็นไปได้

แน่นอนว่ามันไร้สาระวันนี้ด้วยพื้นที่เก็บข้อมูลไม่ จำกัด บนฮาร์ดไดรฟ์ แต่มันเป็นส่วนหนึ่งของเหตุผลว่าทำไม C มีไวยากรณ์แปลก ๆ โดยทั่วไป

เกี่ยวกับพอยน์เตอร์ของอาร์เรย์โดยเฉพาะตัวอย่างที่สองของคุณควรเป็นint (*p)[10];(ใช่ซินแท็คซ์สับสนมาก) ฉันอาจจะอ่านว่าเป็น "int pointer to array สิบ" ... ซึ่งค่อนข้างสมเหตุสมผล หากไม่ใช่สำหรับวงเล็บคอมไพเลอร์จะตีความว่ามันเป็นอาร์เรย์ของสิบพอยน์เตอร์แทนซึ่งจะทำให้การประกาศมีความหมายที่แตกต่างกันโดยสิ้นเชิง

เนื่องจากพอยน์เตอร์ของอาเรย์และพอยน์เตอร์ของฟังก์ชั่นทั้งคู่มีไวยากรณ์ค่อนข้างคลุมเครือใน C สิ่งที่สมเหตุสมผลที่ต้องทำคือพิมพ์ความแปลกประหลาดออกไป อาจจะเป็นเช่นนี้:

ตัวอย่างชัดเจน:

int func (int (*arr_ptr)[10])
{
  return 0;
}

int main()
{
  int array[10];
  int (*arr_ptr)[10]  = &array;
  int (*func_ptr)(int(*)[10]) = &func;

  func_ptr(arr_ptr);
}

ตัวอย่างที่ไม่ชัดเจนที่เทียบเท่า:

typedef int array_t[10];
typedef int (*funcptr_t)(array_t*);


int func (array_t* arr_ptr)
{
  return 0;
}

int main()
{
  int        array[10];
  array_t*   arr_ptr  = &array; /* non-obscure array pointer */
  funcptr_t  func_ptr = &func;  /* non-obscure function pointer */

  func_ptr(arr_ptr);
}

สิ่งต่าง ๆ จะมีความชัดเจนยิ่งขึ้นหากคุณกำลังติดต่อกับพอยน์เตอร์ของฟังก์ชัน หรือสิ่งที่คลุมเครือที่สุดของพวกเขาทั้งหมด: ฟังก์ชั่นส่งคืนพอยน์เตอร์ของฟังก์ชั่น หากคุณไม่ได้ใช้ typedefs สำหรับสิ่งต่าง ๆ คุณจะเสียสติอย่างรวดเร็ว

มันค่อนข้างง่าย: int *pหมายความว่า*pเป็น int; int a[5]หมายความว่าa[i]เป็น int

int (*f)(int (*a)[5])

หมายความว่า*fเป็นฟังก์ชั่น*aเป็นอาร์เรย์จำนวนเต็มห้าจำนวนดังนั้นfฟังก์ชั่นจะใช้เป็นตัวชี้ไปยังอาร์เรย์ที่มีจำนวนเต็มห้าจำนวนและส่งคืน int อย่างไรก็ตามใน C มันไม่มีประโยชน์ที่จะส่งตัวชี้ไปยังอาร์เรย์

การประกาศ C ไม่ค่อยมีความซับซ้อนเท่านี้

นอกจากนี้คุณสามารถชี้แจงโดยใช้ typedefs:

typedef int vec5[5];
int (*f)(vec5 *a);

ฉันคิดว่าคุณต้องพิจารณา * [] เป็นตัวดำเนินการที่แนบมากับตัวแปร * ถูกเขียนก่อนตัวแปร [] หลัง

ลองอ่านนิพจน์ประเภท

int* (*p)[10];

ดังนั้นองค์ประกอบภายในสุดคือ p ซึ่งเป็นตัวแปร

p

หมายความว่า: p เป็นตัวแปร

ก่อนที่ตัวแปรจะมี * ผู้ประกอบการ * จะถูกใส่ก่อนนิพจน์ที่อ้างถึงเสมอดังนั้น

(*p)

หมายถึง: ตัวแปร p เป็นตัวชี้ หากไม่มี () ตัวดำเนินการ [] ทางด้านขวาจะมีลำดับความสำคัญสูงกว่าเช่น

**p[]

จะถูกแยกวิเคราะห์เป็น

*(*(p[]))

ขั้นตอนต่อไปคือ []: เนื่องจากไม่มีเพิ่มเติม () ดังนั้น [] จึงมีความสำคัญมากกว่าด้านนอก * ดังนั้น

(*p)[]

หมายถึง: (ตัวแปร p เป็นตัวชี้) ไปยังอาร์เรย์ จากนั้นเรามี * ที่สอง:

* (*p)[]

หมายถึง: ((ตัวแปร p เป็นตัวชี้) ไปยังอาร์เรย์) ของพอยน์เตอร์

ในที่สุดคุณก็มีตัวดำเนินการ int (ชื่อประเภท) ซึ่งมีลำดับความสำคัญต่ำสุด:

int* (*p)[]

หมายถึง: ((((ตัวแปร p เป็นตัวชี้) ไปยังอาร์เรย์) ของตัวชี้) เป็นจำนวนเต็ม

ดังนั้นทั้งระบบจะขึ้นอยู่กับการแสดงออกของประเภทกับผู้ประกอบการและผู้ประกอบการแต่ละคนมีกฎความสำคัญของตัวเอง สิ่งนี้ช่วยในการกำหนดประเภทที่ซับซ้อนมาก

มันไม่ยากนักเมื่อคุณเริ่มคิดและ C ไม่เคยเป็นภาษาที่ง่ายมาก และint*[10]* pไม่ง่ายกว่าจริง ๆint* (*p)[10] และ k แบบไหนที่จะเป็นint*[10]* p, k;