ทำไมอาร์เรย์ C ถึงไม่ติดตามความยาวของมัน

อะไรคือเหตุผลที่อยู่เบื้องหลังไม่แน่ชัดเก็บความยาวของอาร์เรย์กับอาร์เรย์ในC?

วิธีที่ฉันเห็นมันมีเหตุผลมากมายที่ต้องทำเช่นนั้นแต่มีไม่มากนักในการสนับสนุนมาตรฐาน (C89) ตัวอย่างเช่น

1. การมีความยาวที่มีอยู่ในบัฟเฟอร์สามารถป้องกันไม่ให้บัฟเฟอร์มีค่าเกินได้
2. สไตล์ Java arr.lengthมีทั้งชัดเจนและหลีกเลี่ยงโปรแกรมเมอร์จากการรักษาจำนวนมากintในกองหากจัดการกับหลายอาร์เรย์
3. พารามิเตอร์ฟังก์ชั่นกลายเป็นจุดศูนย์กลางมากขึ้น

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

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

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

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

อาร์เรย์ C จะติดตามความยาวของมันเนื่องจากความยาวของอาร์เรย์เป็นคุณสมบัติคงที่:

int xs[42];  /* a 42-element array */

ปกติคุณจะไม่สามารถสืบค้นความยาวนี้ได้ แต่คุณไม่จำเป็นต้องเป็นเพราะมันเป็นแบบคงที่ - เพียงแค่ประกาศXS_LENGTHความยาวของแมโครและคุณก็ทำเสร็จแล้ว

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

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

สิ่งนี้เกี่ยวข้องกับคอมพิวเตอร์ที่มีอยู่ในขณะนั้น โปรแกรมที่คอมไพล์ไม่เพียง แต่ต้องทำงานบนคอมพิวเตอร์ที่มีทรัพยากร จำกัด แต่ที่สำคัญกว่านั้นคอมไพเลอร์เองก็ต้องทำงานบนเครื่องเหล่านี้ ในขณะที่ Thompson พัฒนา C เขาใช้ PDP-7 พร้อม RAM ขนาด 8k คุณสมบัติภาษาที่ซับซ้อนที่ไม่มีอะนาล็อกทันทีบนรหัสเครื่องจริงนั้นไม่ได้รวมอยู่ในภาษา

การอ่านอย่างละเอียดในประวัติของ Cทำให้เกิดความเข้าใจมากขึ้นในข้างต้น แต่มันไม่ได้เกิดจากข้อ จำกัด ของเครื่องจักรที่พวกเขามี:

ยิ่งไปกว่านั้นภาษา (C) แสดงพลังจำนวนมากในการอธิบายแนวคิดที่สำคัญตัวอย่างเช่นเวกเตอร์ที่มีความยาวแตกต่างกันไปในขณะใช้งานโดยมีกฎพื้นฐานเพียงเล็กน้อยเท่านั้น ... มันเป็นเรื่องที่น่าสนใจที่จะเปรียบเทียบวิธีการของ C กับภาษาสองภาษาร่วมกันคือ Algol 68 และ Pascal [Jensen 74] อาร์เรย์ในอัลกอล 68 มีขอบเขตคงที่หรือมีความยืดหยุ่น: จำเป็นต้องใช้กลไกจำนวนมากทั้งในการกำหนดภาษาและในคอมไพเลอร์เพื่อรองรับอาเรย์ที่มีความยืดหยุ่น (และไม่ใช่คอมไพเลอร์ทั้งหมด อาร์เรย์และสตริงและสิ่งนี้พิสูจน์ได้ว่า จำกัด [Kernighan 81]

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

ย้อนกลับไปในวันที่ C ถูกสร้างขึ้นและพื้นที่ 4 ไบต์พิเศษสำหรับทุก ๆ สตริงไม่ว่าจะสั้นแค่ไหนก็เป็นการสิ้นเปลือง!

มีปัญหาอื่น - char*จำไว้ว่าซีจะไม่เชิงวัตถุดังนั้นถ้าคุณทำยาวคำนำหน้าสตริงทั้งหมดก็จะต้องได้รับการกำหนดให้เป็นคอมไพเลอร์ชนิดที่แท้จริงไม่ได้ หากเป็นชนิดพิเศษคุณจะไม่สามารถเปรียบเทียบสตริงกับสตริงคงที่เช่น:

String x = "hello";
if (strcmp(x, "hello") == 0) 
  exit;

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

ฉันคิดว่าท้ายที่สุดพวกเขาไม่ได้เลือกวิธีนำหน้าความยาวเหมือนกับที่พูดว่า Pascal

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

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

void ClearTwoElements(int *ptr)
{
  ptr[-2] = 0;
  ptr[2] = 0;
}
void blah(void)
{
  static int foo[10] = {1,2,3,4,5,6,7,8,9,10};
  ClearTwoElements(foo+2);
  ClearTwoElements(foo+7);
  ClearTwoElements(foo+1);
  ClearTwoElements(foo+8);
}

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

void ClearTwoElements(int *ptr)
{
  int* array_end = ARRAY_END(ptr);
  if ((array_end - ARRAY_BASE(ptr)) < 10 ||
      (ARRAY_BASE(ptr)+4) <= ADDRESS(ptr) ||          
      (array_end - 4) < ADDRESS(ptr)))
    trap();
  *(ADDRESS(ptr) - 4) = 0;
  *(ADDRESS(ptr) + 4) = 0;
}

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

void ClearTwoElements(int arr[], int index)
{
  arr[index-2] = 0;
  arr[index+2] = 0;
}
void blah(void)
{
  static int foo[10] = {1,2,3,4,5,6,7,8,9,10};
  ClearTwoElements(foo,2);
  ClearTwoElements(foo,7);
  ClearTwoElements(foo,1);
  ClearTwoElements(foo,8);
}

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

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

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

คำตอบสั้น ๆ :

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

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

retval = my_func(my_array, my_array_length);

หรือคุณสามารถใช้ struct กับตัวชี้และความยาวหรือวิธีอื่น ๆ

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

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

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

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

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

จากการพัฒนาภาษา C :

ดูเหมือนว่าโครงสร้างควรแมปด้วยวิธีที่ใช้งานง่ายไปยังหน่วยความจำในเครื่อง แต่ในโครงสร้างที่มีอาร์เรย์ไม่มีสถานที่ที่ดีในการซ่อนตัวชี้ที่ประกอบด้วยฐานของอาร์เรย์หรือวิธีที่สะดวกในการจัดเรียงให้เป็น เริ่มต้น ตัวอย่างเช่นรายการไดเรกทอรีของระบบ Unix ยุคแรก ๆ อาจอธิบายไว้ใน C เป็น

struct {
    int inumber;
    char    name[14];
};

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

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

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

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

T *p = &a[0][0];

for ( size_t i = 0; i < rows; i++ )
  for ( size_t j = 0; j < cols; j++ )
    do_something_with( *p++ );

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

รหัสต่อไปนี้คัดลอกข้อมูลบางส่วนจาก src ไปยัง dst ในกลุ่มขนาดใหญ่ที่ไม่ทราบว่าเป็นสตริงอักขระจริง

char src[] = "Hello, world";
char dst[1024];
int *my_array = src; /* What? Compiler warning, but the code is valid. */
int *other_array = dst;
int i;
for (i = 0; i <= sizeof(src)/sizeof(int); i++)
    other_array[i] = my_array[i]; /* Oh well, we've copied some extra bytes */
printf("%s\n", dst);

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