เหตุใดคอมไพเลอร์ C และ C ++ จึงอนุญาตให้มีความยาวอาร์เรย์ในลายเซ็นของฟังก์ชันเมื่อไม่เคยบังคับใช้

นี่คือสิ่งที่ฉันพบในช่วงการเรียนรู้ของฉัน:

#include<iostream>
using namespace std;
int dis(char a[1])
{
    int length = strlen(a);
    char c = a[2];
    return length;
}
int main()
{
    char b[4] = "abc";
    int c = dis(b);
    cout << c;
    return 0;
}  

ดังนั้นในตัวแปรint dis(char a[1])ที่[1]ดูเหมือนว่าจะทำอะไรและไม่ทำงานทั้งหมดเพราะฉันสามารถใช้
a[2]เช่นเดียวกับint a[]หรือchar *a. ฉันรู้ว่าชื่ออาร์เรย์เป็นตัวชี้และวิธีการถ่ายทอดอาร์เรย์ดังนั้นปริศนาของฉันจึงไม่เกี่ยวกับส่วนนี้

สิ่งที่ฉันอยากรู้คือทำไมคอมไพเลอร์ถึงยอมให้มีพฤติกรรมนี้ ( int a[1]) หรือมันมีความหมายอื่นที่ฉันไม่รู้?

มันเป็นมุมแหลมของไวยากรณ์สำหรับการส่งอาร์เรย์ไปยังฟังก์ชัน

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

เนื่องจากตัวชี้ไม่มีข้อมูลความยาวใด ๆ เนื้อหาของคุณ[]ในรายการพารามิเตอร์ที่เป็นทางการของฟังก์ชันจึงถูกละเว้น

การตัดสินใจอนุญาตให้ใช้ไวยากรณ์นี้เกิดขึ้นในปี 1970 และทำให้เกิดความสับสนมากมายนับตั้งแต่ ...

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

#include <stdio.h>

void foo(int args[10][20])
{
    printf("%zd\n", sizeof(args[0]));
}

int main(int argc, char **argv)
{
    int a[2][20];
    foo(a);
    return 0;
}

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

ไบต์ออฟเซ็ตจากฐานของอาร์เรย์ไปยังองค์ประกอบargs[row][col]ถูกกำหนดโดย:

sizeof(int)*(col + 20*row)

โปรดทราบว่าถ้าเป็นcol >= 20เช่นนั้นคุณจะทำดัชนีในแถวถัดไป (หรือปิดท้ายอาร์เรย์ทั้งหมด)

sizeof(args[0])ผลตอบแทนในเครื่องของฉันที่80 sizeof(int) == 4อย่างไรก็ตามหากฉันพยายามรับsizeof(args)ฉันจะได้รับคำเตือนคอมไพเลอร์ดังต่อไปนี้:

foo.c:5:27: warning: sizeof on array function parameter will return size of 'int (*)[20]' instead of 'int [10][20]' [-Wsizeof-array-argument]
    printf("%zd\n", sizeof(args));
                          ^
foo.c:3:14: note: declared here
void foo(int args[10][20])
             ^
1 warning generated.

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

ปัญหาและวิธีเอาชนะใน C ++

ปัญหาที่เกิดขึ้นได้รับการอธิบายอย่างกว้างขวางโดยpatและแมตต์ โดยทั่วไปคอมไพเลอร์จะละเว้นมิติแรกของขนาดของอาร์เรย์อย่างมีประสิทธิภาพโดยไม่สนใจขนาดของอาร์กิวเมนต์ที่ส่งผ่าน

ในทางกลับกัน C ++ คุณสามารถเอาชนะข้อ จำกัด นี้ได้อย่างง่ายดายด้วยสองวิธี:

• ใช้การอ้างอิง
• โดยใช้std::array(ตั้งแต่ C ++ 11)

อ้างอิง

หากฟังก์ชันของคุณพยายามอ่านหรือแก้ไขอาร์เรย์ที่มีอยู่เท่านั้น (ไม่ได้คัดลอก) คุณสามารถใช้การอ้างอิงได้อย่างง่ายดาย

ตัวอย่างเช่นสมมติว่าคุณต้องการให้มีฟังก์ชั่นที่รีเซ็ตอาร์เรย์ของสิบต์ints 0ตั้งค่าองค์ประกอบทุก คุณสามารถทำได้อย่างง่ายดายโดยใช้ลายเซ็นฟังก์ชันต่อไปนี้:

void reset(int (&array)[10]) { ... }

ไม่เพียง แต่จะใช้งานได้ดีเท่านั้น แต่ยังบังคับใช้มิติของอาร์เรย์ด้วย

นอกจากนี้คุณยังสามารถใช้เทมเพลตเพื่อสร้างโค้ดด้านบนทั่วไปได้ :

template<class Type, std::size_t N>
void reset(Type (&array)[N]) { ... }

และสุดท้ายคุณสามารถใช้ประโยชน์จากconstความถูกต้อง ลองพิจารณาฟังก์ชันที่พิมพ์อาร์เรย์ 10 องค์ประกอบ:

void show(const int (&array)[10]) { ... }

โดยใช้constรอบคัดเลือกเราจะป้องกันไม่ให้มีการปรับเปลี่ยนไปได้

คลาสไลบรารีมาตรฐานสำหรับอาร์เรย์

หากคุณพิจารณาไวยากรณ์ข้างต้นทั้งน่าเกลียดและไม่จำเป็นอย่างที่ฉันทำเราสามารถโยนมันลงในกระป๋องและใช้std::arrayแทน (ตั้งแต่ C ++ 11)

นี่คือรหัส refactored:

void reset(std::array<int, 10>& array) { ... }
void show(std::array<int, 10> const& array) { ... }

มันวิเศษไม่ใช่เหรอ? ไม่ต้องพูดถึงว่าเคล็ดลับรหัสทั่วไปที่ฉันเคยสอนคุณไปก่อนหน้านี้ยังใช้งานได้:

template<class Type, std::size_t N>
void reset(std::array<Type, N>& array) { ... }

template<class Type, std::size_t N>
void show(const std::array<Type, N>& array) { ... }

ไม่เพียงแค่นั้น แต่คุณจะได้รับสำเนาและย้ายความหมายได้ฟรี :)

void copy(std::array<Type, N> array) {
    // a copy of the original passed array 
    // is made and can be dealt with indipendently
    // from the original
}

ดังนั้นสิ่งที่คุณรอ? ไปใช้std::array.

เป็นคุณสมบัติที่น่าสนุกของCที่ช่วยให้คุณยิงเท้าตัวเองได้อย่างมีประสิทธิภาพหากคุณเอียงมาก

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

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

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

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

typedef struct {
  int a[10];
} myarray_t;

myarray_t my_function(myarray_t foo) {

  myarray_t bar;

  ...

  return bar;

}

คุณต้องเข้าถึงองค์ประกอบเช่นนี้: foo.a [1] ".a" พิเศษอาจดูแปลก ๆ แต่เคล็ดลับนี้ช่วยเพิ่มฟังก์ชันการทำงานที่ยอดเยี่ยมให้กับภาษา C

เพื่อบอกคอมไพเลอร์ว่า myArray ชี้ไปที่อาร์เรย์อย่างน้อย 10 ints:

void bar(int myArray[static 10])

คอมไพเลอร์ที่ดีควรแจ้งเตือนคุณหากคุณเข้าถึง myArray [10] หากไม่มีคีย์เวิร์ด "คงที่" คำหลัก 10 คำจะไม่มีความหมายเลย

นี่คือ "คุณลักษณะ" ที่รู้จักกันดีของ C ซึ่งส่งต่อไปยัง C ++ เนื่องจาก C ++ ควรรวบรวมรหัส C อย่างถูกต้อง

ปัญหาเกิดจากหลายด้าน:

1. ชื่ออาร์เรย์ควรจะเทียบเท่ากับตัวชี้
2. C ควรจะเร็ว แต่เดิมผู้พัฒนาเป็น "แอสเซมเบลอร์ระดับสูง" ชนิดหนึ่ง (ออกแบบมาโดยเฉพาะเพื่อเขียน "ระบบปฏิบัติการพกพา" ตัวแรก: Unix) ดังนั้นจึงไม่ใช่ควรแทรกโค้ด "ซ่อน" การตรวจสอบช่วงรันไทม์จึงเป็น "สิ่งต้องห้าม"
3. รหัสเครื่องที่สร้างขึ้นเพื่อเข้าถึงอาร์เรย์แบบคงที่หรือแบบไดนามิก (ไม่ว่าจะในสแต็กหรือจัดสรร) นั้นแตกต่างกันจริงๆ
4. เนื่องจากฟังก์ชันที่เรียกว่าไม่สามารถทราบ "ชนิด" ของอาร์เรย์ที่ส่งผ่านไปได้เนื่องจากอาร์กิวเมนต์ทุกอย่างควรเป็นตัวชี้และถือว่าเป็นเช่นนั้น

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

อย่างไรก็ตามทั้งหมดข้างต้นไม่เป็นความจริงอีกต่อไป: p

ที่ทันสมัยที่สุด C / C ++ คอมไพเลอร์ทำขอบเขตการสนับสนุนการตรวจสอบ แต่มาตรฐานต้องมันจะปิดโดยปริยาย (สำหรับความเข้ากันได้ย้อนหลัง) gcc เวอร์ชันล่าสุดอย่างสมเหตุสมผลเช่นทำการตรวจสอบช่วงเวลาคอมไพล์ด้วย "-O3 -Wall -Wextra" และการตรวจสอบขอบเขตรันไทม์แบบเต็มด้วย "-fbounds-checked"

C จะไม่เพียง แต่แปลงพารามิเตอร์ประเภทint[5]เป็น*int; ได้รับการประกาศtypedef int intArray5[5];ก็จะเปลี่ยนพารามิเตอร์ของประเภทintArray5จะ*intได้เป็นอย่างดี มีบางสถานการณ์ที่พฤติกรรมนี้แม้จะแปลก แต่ก็มีประโยชน์ (โดยเฉพาะอย่างยิ่งกับสิ่งต่างๆเช่นที่va_listกำหนดไว้stdargs.hซึ่งการใช้งานบางอย่างกำหนดเป็นอาร์เรย์) การอนุญาตให้เป็นประเภทพารามิเตอร์ที่กำหนดเป็นint[5](การละเว้นมิติข้อมูล) เป็นเรื่องที่สมเหตุสมผลแต่ไม่อนุญาตint[5]ระบุโดยตรง

ฉันพบว่าการจัดการพารามิเตอร์ประเภทอาร์เรย์ของ C เป็นเรื่องไร้สาระ แต่เป็นผลมาจากความพยายามที่จะใช้ภาษาเฉพาะกิจซึ่งส่วนใหญ่ไม่ได้มีการกำหนดหรือคิดออกมาเป็นอย่างดีโดยเฉพาะและพยายามหาพฤติกรรม ข้อกำหนดที่สอดคล้องกับการใช้งานที่มีอยู่สำหรับโปรแกรมที่มีอยู่ นิสัยใจคอของ C หลายอย่างมีความหมายเมื่อมองในแง่นั้นโดยเฉพาะอย่างยิ่งถ้ามีคนคิดว่าเมื่อหลายคนถูกประดิษฐ์ขึ้นส่วนใหญ่ของภาษาที่เรารู้จักในปัจจุบันยังไม่มีอยู่จริง จากสิ่งที่ฉันเข้าใจในรุ่นก่อนถึง C เรียกว่า BCPL คอมไพเลอร์ไม่ได้ติดตามประเภทตัวแปรได้ดีนัก การประกาศint arr[5];เทียบเท่ากับint anonymousAllocation[5],*arr = anonymousAllocation;; เมื่อจัดสรรการจัดสรรแล้ว คอมไพเลอร์ไม่รู้หรือไม่สนใจว่าarrเป็นตัวชี้หรืออาร์เรย์ เมื่อเข้าถึงเป็นอย่างใดอย่างหนึ่งarr[x]หรือ*arrจะถือว่าเป็นตัวชี้ไม่ว่าจะประกาศด้วยวิธีใดก็ตาม

สิ่งหนึ่งที่ยังไม่ได้รับคำตอบคือคำถามที่แท้จริง

คำตอบที่ให้ไปแล้วอธิบายว่าอาร์เรย์ไม่สามารถส่งผ่านค่าไปยังฟังก์ชันใน C หรือ C ++ นอกจากนี้ยังอธิบายด้วยว่าพารามิเตอร์ที่ประกาศเป็นint[]จะถือว่าเป็นประเภทint *และตัวแปรประเภทint[]สามารถส่งผ่านไปยังฟังก์ชันดังกล่าวได้

แต่พวกเขาไม่ได้อธิบายว่าเหตุใดจึงไม่เคยเกิดข้อผิดพลาดในการระบุความยาวอาร์เรย์อย่างชัดเจน

void f(int *); // makes perfect sense
void f(int []); // sort of makes sense
void f(int [10]); // makes no sense

เหตุใดสุดท้ายจึงไม่เกิดข้อผิดพลาด

เหตุผลก็คือมันทำให้เกิดปัญหากับ typedefs

typedef int myarray[10];
void f(myarray array);

หากเป็นข้อผิดพลาดในการระบุความยาวอาร์เรย์ในพารามิเตอร์ฟังก์ชันคุณจะไม่สามารถใช้myarrayชื่อในพารามิเตอร์ฟังก์ชันได้ และเนื่องจากการใช้งานบางอย่างใช้ประเภทอาร์เรย์สำหรับประเภทไลบรารีมาตรฐานเช่นva_listและการใช้งานทั้งหมดจำเป็นต้องสร้างjmp_bufประเภทอาร์เรย์จึงเป็นปัญหามากหากไม่มีวิธีมาตรฐานในการประกาศพารามิเตอร์ฟังก์ชันโดยใช้ชื่อเหล่านั้น: หากไม่มีความสามารถดังกล่าวก็สามารถทำได้ ไม่ใช่การนำฟังก์ชันแบบพกพาเช่นvprintf.

อนุญาตให้คอมไพเลอร์ตรวจสอบได้ว่าขนาดของอาร์เรย์ที่ส่งผ่านนั้นตรงกับที่คาดไว้หรือไม่ คอมไพเลอร์อาจเตือนปัญหาหากไม่เป็นเช่นนั้น