Tại sao mảng C không theo dõi chiều dài của chúng?

Lý do đằng sau không lưu trữ rõ ràng độ dài của một mảng với một mảng là Cgì?

Theo cách tôi thấy, có rất nhiều lý do để làm như vậy nhưng không có nhiều sự hỗ trợ của tiêu chuẩn (C89). Ví dụ:

1. Có chiều dài có sẵn trong một bộ đệm có thể ngăn chặn tràn bộ đệm.
2. Kiểu Java arr.lengthvừa rõ ràng vừa giúp người lập trình không phải duy trì nhiều ints trên ngăn xếp nếu xử lý một số mảng
3. Các tham số chức năng trở nên hợp tác hơn.

Nhưng có lẽ lý do thúc đẩy nhất, theo tôi, là thông thường, không có không gian nào được lưu mà không giữ được chiều dài. Tôi muốn mạo hiểm nói rằng hầu hết việc sử dụng mảng liên quan đến phân bổ động. Đúng, có thể có một số trường hợp mọi người sử dụng một mảng được phân bổ trên ngăn xếp, nhưng đó chỉ là một hàm gọi * - ngăn xếp có thể xử lý thêm 4 hoặc 8 byte.

Vì trình quản lý heap phải theo dõi kích thước khối miễn phí được sử dụng bởi mảng được phân bổ động, tại sao không làm cho thông tin đó có thể sử dụng được (và thêm quy tắc bổ sung, được kiểm tra tại thời điểm biên dịch, rằng người ta không thể thao tác độ dài một cách rõ ràng trừ khi người ta sẽ thích tự bắn vào chân mình).

Điều duy nhất tôi có thể nghĩ đến ở phía bên kia là không theo dõi chiều dài có thể đã thực hiện các trình biên dịch đơn giản, nhưng không phải là đơn giản hơn nhiều.

* Về mặt kỹ thuật, người ta có thể viết một số loại hàm đệ quy với một mảng có lưu trữ tự động, và trong trường hợp (rất công phu) này lưu trữ độ dài thực sự có thể dẫn đến việc sử dụng không gian hiệu quả hơn.

Mảng C theo dõi chiều dài của chúng, vì chiều dài mảng là thuộc tính tĩnh:

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

Bạn thường không thể truy vấn độ dài này, nhưng bạn không cần phải vì dù sao nó cũng tĩnh - chỉ cần khai báo một macro XS_LENGTHcho độ dài và bạn đã hoàn thành.

Vấn đề quan trọng hơn là các mảng C hoàn toàn suy biến thành các con trỏ, ví dụ như khi được truyền cho một hàm. Điều này có ý nghĩa gì đó, và cho phép một số thủ thuật cấp thấp đẹp, nhưng nó làm mất thông tin về độ dài của mảng. Vì vậy, một câu hỏi tốt hơn sẽ là tại sao C được thiết kế với sự xuống cấp ngầm định này cho con trỏ.

Một vấn đề khác là con trỏ không cần lưu trữ ngoại trừ chính địa chỉ bộ nhớ. C cho phép chúng ta truyền các số nguyên cho con trỏ, con trỏ tới các con trỏ khác và xử lý các con trỏ như thể chúng là các mảng. Trong khi thực hiện điều này, C không đủ điên rồ để chế tạo một số chiều dài mảng tồn tại, nhưng dường như tin tưởng vào phương châm của Người nhện: với sức mạnh lớn, lập trình viên sẽ hy vọng hoàn thành trách nhiệm lớn trong việc theo dõi độ dài và tràn.

Rất nhiều thứ phải làm với các máy tính có sẵn tại thời điểm đó. Chương trình biên dịch không chỉ phải chạy trên một máy tính tài nguyên hạn chế, mà, có lẽ quan trọng hơn, chính trình biên dịch cũng phải chạy trên các máy này. Vào thời điểm Thompson phát triển C, anh ta đang sử dụng PDP-7, với 8k RAM. Các tính năng ngôn ngữ phức tạp không có sự tương tự ngay lập tức trên mã máy thực tế đơn giản là không được bao gồm trong ngôn ngữ.

Đọc kỹ lịch sử của C mang lại nhiều hiểu biết hơn ở trên, nhưng nó hoàn toàn không phải là kết quả của những hạn chế máy móc mà họ có:

Hơn nữa, ngôn ngữ (C) cho thấy sức mạnh đáng kể để mô tả các khái niệm quan trọng, ví dụ, các vectơ có chiều dài thay đổi theo thời gian chạy, chỉ có một vài quy tắc và quy ước cơ bản. ... Thật thú vị khi so sánh cách tiếp cận của C với hai ngôn ngữ gần như cùng thời, Algol 68 và Pascal [Jensen 74]. Các mảng trong Algol 68 hoặc có giới hạn cố định hoặc 'linh hoạt:' cần có cơ chế đáng kể cả về định nghĩa ngôn ngữ và trong trình biên dịch, để chứa các mảng linh hoạt (và không phải tất cả các trình biên dịch đều thực hiện đầy đủ chúng.) Pascal gốc chỉ có kích thước cố định mảng và chuỗi, và điều này đã chứng minh giới hạn [Kernighan 81].

Mảng C vốn đã mạnh hơn. Thêm giới hạn cho họ hạn chế những gì lập trình viên có thể sử dụng chúng cho. Những hạn chế như vậy có thể hữu ích cho các lập trình viên, nhưng nhất thiết cũng hạn chế.

Quay lại ngày mà C được tạo và thêm 4 byte không gian cho mỗi chuỗi cho dù ngắn đến đâu cũng sẽ khá lãng phí!

Có một vấn đề khác - hãy nhớ rằng C không hướng đối tượng, vì vậy nếu bạn thực hiện tiền tố dài tất cả các chuỗi, thì nó sẽ phải được định nghĩa là loại nội tại của trình biên dịch, không phải là a char*. Nếu đó là một loại đặc biệt, thì bạn sẽ không thể so sánh một chuỗi với một chuỗi không đổi, tức là:

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

sẽ phải có các chi tiết trình biên dịch đặc biệt để chuyển đổi chuỗi tĩnh đó thành Chuỗi hoặc có các hàm chuỗi khác nhau để tính đến tiền tố độ dài.

Cuối cùng tôi nghĩ, họ chỉ không chọn cách tiền tố dài không giống như nói Pascal.

Trong C, bất kỳ tập hợp con liền kề nào của một mảng cũng là một mảng và có thể được vận hành như vậy. Điều này áp dụng cho cả hoạt động đọc và viết. Thuộc tính này sẽ không giữ nếu kích thước được lưu trữ rõ ràng.

Vấn đề lớn nhất với việc các mảng được gắn thẻ với độ dài của chúng không phải là không gian cần thiết để lưu trữ độ dài đó, cũng không phải là câu hỏi về cách lưu trữ (sử dụng thêm một byte cho các mảng ngắn thường không bị phản đối, cũng không sử dụng bốn thêm byte cho mảng dài, nhưng sử dụng bốn byte ngay cả đối với mảng ngắn có thể). Một vấn đề lớn hơn nhiều là mã đã cho như:

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);
}

cách duy nhất mà mã có thể chấp nhận cuộc gọi đầu tiên đến ClearTwoElementsnhưng từ chối cuộc gọi thứ hai là ClearTwoElementsphương thức nhận đủ thông tin để biết rằng trong mỗi trường hợp, nó nhận được một tham chiếu đến một phần của mảng foongoài việc biết phần nào. Điều đó thường sẽ tăng gấp đôi chi phí chuyển các tham số con trỏ. Hơn nữa, nếu mỗi mảng được dẫn trước bởi một con trỏ đến một địa chỉ vừa qua cuối (định dạng hiệu quả nhất để xác thực), mã được tối ưu hóa ClearTwoElementscó thể sẽ trở thành một cái gì đó như:

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;
}

Lưu ý rằng, nói chung, một người gọi phương thức có thể hoàn toàn hợp pháp chuyển một con trỏ đến đầu mảng hoặc phần tử cuối cùng cho một phương thức; chỉ khi phương thức cố gắng truy cập các phần tử nằm ngoài mảng truyền vào thì các con trỏ như vậy mới gây ra sự cố. Do đó, trước tiên, một phương thức được gọi sẽ phải đảm bảo mảng đủ lớn để số học con trỏ xác thực các đối số của nó sẽ không vượt quá giới hạn và sau đó thực hiện một số tính toán con trỏ để xác thực các đối số. Thời gian dành cho việc xác nhận như vậy có thể sẽ vượt quá chi phí dành cho bất kỳ công việc thực tế nào. Hơn nữa, phương pháp có thể có hiệu quả hơn nếu nó được viết và gọi:

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);
}

Khái niệm về một loại kết hợp một cái gì đó để xác định một đối tượng với một cái gì đó để xác định một mảnh của nó là một loại tốt. Tuy nhiên, một con trỏ kiểu C sẽ nhanh hơn nếu không cần thiết phải thực hiện xác nhận.

Một trong những khác biệt cơ bản giữa C và hầu hết các ngôn ngữ thế hệ thứ 3 khác, và tất cả các ngôn ngữ gần đây mà tôi biết, là C không được thiết kế để giúp cuộc sống dễ dàng hơn hoặc an toàn hơn cho lập trình viên. Nó được thiết kế với mong muốn lập trình viên biết họ đang làm gì và muốn làm chính xác và chỉ có thế. Nó không làm bất cứ điều gì 'đằng sau hậu trường' để bạn không gặp phải bất ngờ nào. Ngay cả tối ưu hóa mức biên dịch là tùy chọn (trừ khi bạn sử dụng trình biên dịch Microsoft).

Nếu một lập trình viên muốn viết giới hạn kiểm tra mã của họ, C làm cho nó đủ đơn giản để làm điều đó, nhưng lập trình viên phải chọn trả giá tương ứng về không gian, độ phức tạp và hiệu suất. Mặc dù tôi đã không sử dụng nó trong sự tức giận trong nhiều năm, tôi vẫn sử dụng nó khi dạy lập trình để vượt qua khái niệm về việc ra quyết định dựa trên ràng buộc. Về cơ bản, điều đó có nghĩa là bạn có thể chọn làm bất cứ điều gì bạn muốn, nhưng mọi quyết định bạn đưa ra đều có một mức giá mà bạn cần phải biết. Điều này càng trở nên quan trọng hơn khi bạn bắt đầu nói với người khác những gì bạn muốn chương trình của họ làm.

Câu trả lời ngắn:

Bởi vì C là ngôn ngữ lập trình cấp thấp , nó hy vọng bạn sẽ tự xử lý các vấn đề này, nhưng điều này sẽ tăng tính linh hoạt cao hơn trong chính xác cách bạn thực hiện nó.

C có một khái niệm thời gian biên dịch của một mảng được khởi tạo với độ dài nhưng trong thời gian chạy, toàn bộ mọi thứ chỉ được lưu trữ dưới dạng một con trỏ duy nhất để bắt đầu dữ liệu. Nếu bạn muốn truyền chiều dài mảng cho một hàm cùng với mảng, bạn tự làm điều đó:

retval = my_func(my_array, my_array_length);

Hoặc bạn có thể sử dụng một cấu trúc với một con trỏ và chiều dài, hoặc bất kỳ giải pháp nào khác.

Một ngôn ngữ cấp cao hơn sẽ làm điều này cho bạn như là một phần của kiểu mảng của nó. Trong C, bạn được giao trách nhiệm tự làm việc này, nhưng cũng có thể linh hoạt chọn cách thực hiện. Và nếu tất cả các mã bạn đang viết đã biết độ dài của mảng, bạn không cần phải vượt qua độ dài xung quanh dưới dạng một biến.

Hạn chế rõ ràng là không có giới hạn vốn có kiểm tra các mảng được truyền xung quanh dưới dạng con trỏ, bạn có thể tạo một số mã nguy hiểm nhưng đó là bản chất của ngôn ngữ hệ thống / cấp độ thấp và sự đánh đổi mà chúng đưa ra.

Vấn đề lưu trữ thêm là một vấn đề, nhưng theo tôi là một vấn đề nhỏ. Rốt cuộc, hầu hết thời gian bạn sẽ cần theo dõi độ dài dù thế nào, mặc dù amon đã đưa ra một điểm tốt là nó thường có thể được theo dõi tĩnh.

Một vấn đề lớn hơn là nơi lưu trữ chiều dài và thời gian thực hiện. Không có một nơi nào hoạt động trong mọi tình huống. Bạn có thể nói chỉ lưu trữ độ dài trong bộ nhớ ngay trước dữ liệu. Điều gì xảy ra nếu mảng không trỏ đến bộ nhớ, nhưng một cái gì đó giống như bộ đệm UART?

Thoát khỏi độ dài cho phép lập trình viên tạo ra sự trừu tượng của riêng mình cho tình huống thích hợp và có rất nhiều thư viện đã sẵn sàng cho trường hợp mục đích chung. Câu hỏi thực sự là tại sao những thứ trừu tượng đó không được sử dụng trong các ứng dụng nhạy cảm với bảo mật?

Từ sự phát triển của ngôn ngữ C :

Các cấu trúc, dường như, ánh xạ một cách trực quan vào bộ nhớ trong máy, nhưng trong một cấu trúc có chứa một mảng, không có nơi nào tốt để bỏ con trỏ chứa cơ sở của mảng, cũng không có cách nào thuận tiện để sắp xếp nó. khởi tạo. Ví dụ, các mục nhập thư mục của các hệ thống Unix đầu tiên có thể được mô tả trong C là

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

Tôi muốn cấu trúc không chỉ đơn thuần là để mô tả một đối tượng trừu tượng mà còn để mô tả một tập hợp các bit có thể được đọc từ một thư mục. Trình biên dịch có thể ẩn con trỏ đến namengữ nghĩa yêu cầu ở đâu? Ngay cả khi các cấu trúc được cho là trừu tượng hơn và không gian cho con trỏ có thể bị ẩn đi bằng cách nào đó, làm thế nào tôi có thể xử lý vấn đề kỹ thuật khởi tạo đúng các con trỏ này khi phân bổ một đối tượng phức tạp, có lẽ là một cấu trúc chỉ định các mảng chứa cấu trúc có độ sâu tùy ý?

Giải pháp cấu thành bước nhảy quan trọng trong chuỗi tiến hóa giữa BCPL không chữ và gõ C. Nó đã loại bỏ sự vật chất hóa của con trỏ trong lưu trữ, và thay vào đó gây ra việc tạo con trỏ khi tên mảng được đề cập trong một biểu thức. Quy tắc, tồn tại trong C ngày nay, là các giá trị của kiểu mảng được chuyển đổi, khi chúng xuất hiện trong biểu thức, thành con trỏ đến đầu tiên của các đối tượng tạo thành mảng.

Đoạn văn đó giải quyết tại sao các biểu thức mảng phân rã thành con trỏ trong hầu hết các trường hợp, nhưng lý do tương tự áp dụng cho lý do tại sao độ dài mảng không được lưu trữ với chính mảng đó; nếu bạn muốn ánh xạ một-một giữa định nghĩa kiểu và biểu diễn của nó trong bộ nhớ (như Ritchie đã làm), thì không có nơi nào tốt để lưu trữ siêu dữ liệu đó.

Ngoài ra, hãy suy nghĩ về mảng đa chiều; nơi bạn sẽ lưu trữ siêu dữ liệu độ dài cho mỗi thứ nguyên để bạn vẫn có thể đi qua mảng với thứ gì đó như

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++ );

Câu hỏi giả định rằng có các mảng trong C. Không có. Những thứ được gọi là mảng chỉ là một đường cú pháp cho các hoạt động trên chuỗi liên tục của dữ liệu và con trỏ mỹ phẩm.

Đoạn mã sau sao chép một số dữ liệu từ src sang dst trong các đoạn có kích thước int mà không biết rằng đó thực sự là chuỗi ký tự.

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);

Tại sao C đơn giản đến mức nó không có mảng thích hợp? Tôi không biết câu trả lời chính xác cho câu hỏi mới này. Nhưng một số người thường nói rằng C chỉ là (phần nào) dễ đọc hơn và trình biên dịch di động.