Tại sao trình biên dịch C và C ++ cho phép độ dài mảng trong chữ ký hàm khi chúng không bao giờ được thi hành?

Đây là những gì tôi tìm thấy trong thời gian họ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;
}  

Vì vậy, trong biến int dis(char a[1]), [1]dường như không làm gì cả và không hoạt động
, bởi vì tôi có thể sử dụng a[2]. Chỉ thích int a[]hoặc char *a. Tôi biết tên mảng là một con trỏ và cách truyền tải một mảng, vì vậy câu đố của tôi không phải là về phần này.

Những gì tôi muốn biết là tại sao trình biên dịch cho phép hành vi này ( int a[1]). Hay nó có ý nghĩa khác mà tôi không biết?

Đây là một cách giải quyết cú pháp để truyền mảng cho các hàm.

Trên thực tế không thể truyền một mảng trong C. Nếu bạn viết cú pháp trông giống như nó sẽ vượt qua mảng, điều thực sự xảy ra là một con trỏ đến phần tử đầu tiên của mảng được truyền thay thế.

Vì con trỏ không bao gồm bất kỳ thông tin độ dài nào, nên nội dung của bạn []trong danh sách tham số chính thức của hàm thực sự bị bỏ qua.

Quyết định cho phép cú pháp này được đưa ra vào những năm 1970 và đã gây ra nhiều nhầm lẫn kể từ khi ...

Độ dài của kích thước đầu tiên được bỏ qua, nhưng độ dài của các kích thước bổ sung là cần thiết để cho phép trình biên dịch tính toán bù đắp chính xác. Trong ví dụ sau, foohàm được truyền một con trỏ tới mảng hai chiều.

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

Kích thước của kích thước đầu tiên [10]được bỏ qua; trình biên dịch sẽ không ngăn bạn lập chỉ mục kết thúc (lưu ý rằng chính thức muốn 10 phần tử, nhưng thực tế chỉ cung cấp 2). Tuy nhiên, kích thước của kích thước thứ hai [20]được sử dụng để xác định bước tiến của mỗi hàng và ở đây, chính thức phải phù hợp với thực tế. Một lần nữa, trình biên dịch sẽ không ngăn bạn lập chỉ mục ở cuối chiều thứ hai.

Độ lệch byte từ gốc của mảng đến một phần tử args[row][col]được xác định bởi:

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

Lưu ý rằng nếu col >= 20, thì bạn thực sự sẽ lập chỉ mục vào một hàng tiếp theo (hoặc tắt cuối toàn bộ mảng).

sizeof(args[0]), trả 80về máy của tôi đâu sizeof(int) == 4. Tuy nhiên, nếu tôi cố gắng thực hiện sizeof(args), tôi nhận được cảnh báo trình biên dịch sau:

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.

Ở đây, trình biên dịch cảnh báo rằng nó sẽ chỉ đưa ra kích thước của con trỏ mà mảng đã phân rã thay vì kích thước của chính mảng đó.

Vấn đề và cách khắc phục nó trong C ++

Vấn đề đã được giải thích rộng rãi bởi pat và Matt . Trình biên dịch về cơ bản bỏ qua kích thước đầu tiên của kích thước của mảng có hiệu quả bỏ qua kích thước của đối số được truyền.

Mặt khác, trong C ++, bạn có thể dễ dàng vượt qua giới hạn này theo hai cách:

• sử dụng tài liệu tham khảo
• sử dụng std::array(kể từ C ++ 11)

Người giới thiệu

Nếu chức năng của bạn chỉ cố đọc hoặc sửa đổi một mảng hiện có (không sao chép nó), bạn có thể dễ dàng sử dụng tài liệu tham khảo.

Ví dụ: giả sử bạn muốn có một hàm đặt lại một mảng mười ints cài đặt mọi phần tử thành 0. Bạn có thể dễ dàng làm điều đó bằng cách sử dụng chữ ký hàm sau:

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

Điều này không chỉ hoạt động tốt , mà còn thực thi kích thước của mảng .

Bạn cũng có thể sử dụng các mẫu để tạo mã chung ở trên :

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

Và cuối cùng bạn có thể tận dụng constsự đúng đắn. Hãy xem xét một chức năng in một mảng gồm 10 phần tử:

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

Bằng cách áp dụng constvòng loại, chúng tôi đang ngăn chặn các sửa đổi có thể .

Lớp thư viện chuẩn cho mảng

Nếu bạn xem xét cú pháp trên cả xấu và không cần thiết, như tôi làm, chúng ta có thể ném nó vào can và sử dụng std::arraythay thế (kể từ C ++ 11).

Đây là mã được cấu trúc lại:

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

Thật tuyệt phải không? Chưa kể rằng thủ thuật mã chung mà tôi đã dạy trước đó, vẫn hoạt động:

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) { ... }

Không chỉ vậy, nhưng bạn có được bản sao và di chuyển ngữ nghĩa miễn phí. :)

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
}

Bạn đang chờ đợi điều gì? Đi sử dụng std::array.

Đây là một tính năng thú vị của C cho phép bạn tự bắn vào chân mình một cách hiệu quả nếu bạn quá nghiêng.

Tôi nghĩ lý do là C chỉ là một bước trên ngôn ngữ lắp ráp. Kiểm tra kích thước và các tính năng an toàn tương tự đã được gỡ bỏ để cho phép hiệu suất cao nhất, đó không phải là điều xấu nếu lập trình viên rất siêng năng.

Ngoài ra, việc gán kích thước cho đối số hàm có lợi thế là khi hàm được sử dụng bởi một lập trình viên khác, có khả năng họ sẽ nhận thấy hạn chế kích thước. Chỉ sử dụng một con trỏ không truyền đạt thông tin đó cho lập trình viên tiếp theo.

Đầu tiên, C không bao giờ kiểm tra giới hạn mảng. Không quan trọng nếu chúng là cục bộ, toàn cầu, tĩnh, tham số, bất cứ điều gì. Kiểm tra giới hạn mảng có nghĩa là xử lý nhiều hơn và C được cho là rất hiệu quả, vì vậy việc kiểm tra giới hạn mảng được thực hiện bởi lập trình viên khi cần.

Thứ hai, có một mẹo giúp cho việc truyền từng giá trị cho một hàm vào một hàm. Cũng có thể trả về giá trị một mảng từ một hàm. Bạn chỉ cần tạo một kiểu dữ liệu mới bằng struct. Ví dụ:

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

myarray_t my_function(myarray_t foo) {

  myarray_t bar;

  ...

  return bar;

}

Bạn phải truy cập các yếu tố như thế này: foo.a [1]. Chữ ".a" thêm có thể trông lạ, nhưng thủ thuật này thêm chức năng tuyệt vời cho ngôn ngữ C.

Để báo cho trình biên dịch rằng myArray trỏ đến một mảng có ít nhất 10 ints:

void bar(int myArray[static 10])

Một trình biên dịch tốt sẽ đưa ra cảnh báo nếu bạn truy cập myArray [10]. Nếu không có từ khóa "tĩnh", số 10 sẽ không có nghĩa gì cả.

Đây là một "tính năng" nổi tiếng của C, được chuyển qua C ++ vì C ++ được cho là biên dịch chính xác mã C.

Vấn đề phát sinh từ một số khía cạnh:

1. Một tên mảng được cho là hoàn toàn tương đương với một con trỏ.
2. C được cho là nhanh, ban đầu nhà phát triển là một loại "Trình biên dịch cấp cao" (đặc biệt được thiết kế để viết "Hệ điều hành di động" đầu tiên: Unix), vì vậy nó là không phải nên chèn mã "ẩn"; Do đó, kiểm tra phạm vi thời gian chạy là "bị cấm".
3. Mã máy được tạo ra để truy cập vào một mảng tĩnh hoặc một mảng động (trong ngăn xếp hoặc được phân bổ) thực sự khác nhau.
4. Vì hàm được gọi không thể biết "loại" của mảng được truyền dưới dạng đối số, mọi thứ được coi là một con trỏ và được xử lý như vậy.

Bạn có thể nói mảng không thực sự được hỗ trợ trong C (điều này không thực sự đúng, như tôi đã nói trước đây, nhưng đó là một xấp xỉ tốt); một mảng thực sự được coi là một con trỏ tới một khối dữ liệu và được truy cập bằng số học con trỏ. Vì C KHÔNG có bất kỳ dạng RTTI nào, bạn phải khai báo kích thước của phần tử mảng trong nguyên mẫu hàm (để hỗ trợ số học con trỏ). Điều này thậm chí còn "đúng hơn" đối với các mảng đa chiều.

Dù sao tất cả những điều trên không thực sự đúng nữa: p

Hầu hết các trình biên dịch C / C ++ hiện đại đều hỗ trợ kiểm tra giới hạn, nhưng các tiêu chuẩn yêu cầu tắt theo mặc định (để tương thích ngược). Các phiên bản hợp lý gần đây của gcc, ví dụ, thực hiện kiểm tra phạm vi thời gian biên dịch với "-O3 -Wall -Wextra" và kiểm tra giới hạn thời gian chạy đầy đủ với "kiểm tra giới hạn".

C sẽ không chỉ biến đổi một tham số loại int[5]thành *int; cho việc kê khai typedef int intArray5[5];, nó sẽ biến đổi một tham số kiểu intArray5để *intlà tốt. Có một số tình huống trong đó hành vi này, mặc dù kỳ lạ, rất hữu ích (đặc biệt là với những thứ như va_listđược định nghĩa trong stdargs.hđó, một số triển khai xác định là một mảng). Sẽ là phi logic khi cho phép như một tham số một loại được xác định là int[5](bỏ qua kích thước) nhưng không cho phépint[5] được chỉ định trực tiếp.

Tôi thấy việc xử lý các tham số của kiểu mảng là vô lý, nhưng đó là kết quả của những nỗ lực để sử dụng ngôn ngữ đặc biệt, phần lớn trong số đó không được xác định rõ hoặc suy nghĩ kỹ và cố gắng đưa ra hành vi thông số kỹ thuật phù hợp với những gì triển khai hiện có đã làm cho các chương trình hiện có. Nhiều điều kỳ quặc của C có ý nghĩa khi được nhìn dưới ánh sáng đó, đặc biệt nếu người ta cho rằng khi nhiều trong số chúng được phát minh, phần lớn ngôn ngữ mà chúng ta biết ngày nay vẫn chưa tồn tại. Theo những gì tôi hiểu, trong tiền thân của C, được gọi là BCPL, trình biên dịch đã không thực sự theo dõi các loại biến rất tốt. Một tuyên bố int arr[5];tương đương với int anonymousAllocation[5],*arr = anonymousAllocation;; một khi phân bổ được đặt sang một bên. trình biên dịch không biết cũng không quan tâmarrlà một con trỏ hoặc một mảng. Khi được truy cập dưới dạng arr[x]hoặc *arr, nó sẽ được coi là một con trỏ bất kể nó được khai báo như thế nào.

Một điều chưa được trả lời là câu hỏi thực tế.

Các câu trả lời đã được đưa ra giải thích rằng các mảng không thể được truyền theo giá trị cho hàm trong C hoặc C ++. Họ cũng giải thích rằng một tham số được khai báo như int[]được xử lý như thể nó có kiểu int *và một biến kiểu int[]có thể được truyền cho hàm như vậy.

Nhưng họ không giải thích lý do tại sao nó chưa bao giờ bị lỗi khi cung cấp độ dài mảng một cách rõ ràng.

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

Tại sao không phải là lỗi cuối cùng?

Một lý do cho điều đó là nó gây ra vấn đề với typedefs.

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

Nếu đó là một lỗi khi chỉ định độ dài mảng trong các tham số hàm, bạn sẽ không thể sử dụng myarraytên trong tham số hàm. Và vì một số triển khai sử dụng các kiểu mảng cho các loại thư viện tiêu chuẩn như va_list, và tất cả các cài đặt được yêu cầu để tạo jmp_bufmột kiểu mảng, sẽ rất khó khăn nếu không có cách khai báo các tham số hàm tiêu chuẩn bằng các tên đó: không có khả năng đó, có thể không được thực hiện di động của các chức năng như vprintf.

Nó cho phép trình biên dịch có thể kiểm tra xem kích thước của mảng được truyền có giống như những gì được mong đợi hay không. Trình biên dịch có thể cảnh báo một vấn đề nếu không phải như vậy.