ผ่านอาร์เรย์โดยอ้างอิง

การส่งผ่านอาร์เรย์ที่จัดสรรแบบคงที่โดยการอ้างอิงทำงานอย่างไร

void foo(int (&myArray)[100])
{
}

int main()
{
    int a[100];
    foo(a);
}

ไม่(&myArray)[100]ได้มีความหมายใด ๆ หรือเพียงแค่ไวยากรณ์ของมันจะผ่านอาร์เรย์ใด ๆ โดยการอ้างอิง? ฉันไม่เข้าใจวงเล็บแยกตามด้วยวงเล็บใหญ่ที่นี่ ขอบคุณ

มันเป็นไวยากรณ์สำหรับการอ้างอิงอาร์เรย์ - คุณจำเป็นต้องใช้(&array)ในการชี้แจงการคอมไพเลอร์ที่คุณต้องการการอ้างอิงไปยังอาร์เรย์มากกว่า (ไม่ถูกต้อง) int & array[100];อาร์เรย์ของการอ้างอิง

แก้ไข: ชี้แจงบางส่วน

void foo(int * x);
void foo(int x[100]);
void foo(int x[]);

ทั้งสามนี้เป็นวิธีการที่แตกต่างกันในการประกาศฟังก์ชั่นเดียวกัน พวกเขาทั้งหมดถือว่าเป็นint *พารามิเตอร์คุณสามารถผ่านอาร์เรย์ขนาดใด ๆ ให้พวกเขา

void foo(int (&x)[100]);

สิ่งนี้ยอมรับเฉพาะอาร์เรย์ของจำนวนเต็ม 100 ตัว คุณสามารถใช้sizeofบนx

void foo(int & x[100]); // error

นี่คือการแยกวิเคราะห์เป็น "อาร์เรย์ของการอ้างอิง" - ซึ่งไม่ถูกกฎหมาย

มันเป็นเพียงไวยากรณ์ที่จำเป็น:

void Func(int (&myArray)[100])

^ ผ่านอาร์เรย์ 100 intโดยอ้างอิงชื่อพารามิเตอร์คือmyArray;

void Func(int* myArray)

^ ส่งผ่านอาร์เรย์ Array จะสลายตัวไปยังตัวชี้ ดังนั้นคุณสูญเสียข้อมูลขนาด

void Func(int (*myFunc)(double))

^ ผ่านตัวชี้ฟังก์ชั่น ฟังก์ชั่นส่งกลับและใช้เวลาint ชื่อพารามิเตอร์doublemyFunc

มันเป็นไวยากรณ์ ในint (&myArray)[100]วงเล็บฟังก์ชั่นข้อโต้แย้งที่ล้อมรอบ&myArrayมีความจำเป็น ถ้าคุณไม่ใช้พวกเขาคุณจะส่งผ่านarray of referencesและนั่นเป็นเพราะมีความสำคัญสูงกว่าsubscript operator []& operator

เช่น int &myArray[100] // array of references

ดังนั้นโดยใช้type construction ()คุณบอกคอมไพเลอร์ว่าคุณต้องการการอ้างอิงถึงอาร์เรย์จำนวนเต็ม 100 ตัว

เช่น int (&myArray)[100] // reference of an array of 100 ints

อาร์เรย์เป็นค่าเริ่มต้นที่ส่งผ่านโดยพอยน์เตอร์ คุณสามารถลองปรับเปลี่ยนอาร์เรย์ภายในการเรียกใช้ฟังก์ชันเพื่อความเข้าใจที่ดีขึ้น

ต่อไปนี้สร้างฟังก์ชั่นทั่วไปรับอาร์เรย์ขนาดใด ๆ และประเภทใด ๆ โดยการอ้างอิง:

template<typename T, std::size_t S>
void my_func(T (&arr)[S]) {
   // do stuff
}

เล่นกับรหัส