Tại sao cú pháp C cho mảng, con trỏ và hàm được thiết kế theo cách này?

Sau khi thấy (và hỏi!) Rất nhiều câu hỏi tương tự như

Không gì int (*f)(int (*a)[5])có nghĩa là trong C?

và thậm chí khi thấy rằng họ đã tạo ra một chương trình để giúp mọi người hiểu cú pháp C, tôi không thể không tự hỏi:

Tại sao cú pháp của C được thiết kế theo cách này?

Ví dụ, nếu tôi đang thiết kế các con trỏ, tôi sẽ dịch "một con trỏ thành một mảng gồm 10 phần tử con trỏ" thành

int*[10]* p;

và không

int* (*p)[10];

mà tôi cảm thấy hầu hết mọi người sẽ đồng ý là ít đơn giản hơn nhiều.

Vì vậy, tôi tự hỏi, tại sao, cú pháp, không trực quan? Có một vấn đề cụ thể mà cú pháp giải quyết (có lẽ là một sự mơ hồ?) Mà tôi không biết?

Sự hiểu biết của tôi về lịch sử của nó là nó dựa trên hai điểm chính ...

Đầu tiên, các tác giả ngôn ngữ ưa thích làm cho cú pháp biến thành trung tâm thay vì kiểu trung tâm. Nghĩa là, họ muốn có một lập trình viên để nhìn vào tờ khai và nghĩ "nếu tôi viết biểu thức *func(arg), mà sẽ dẫn đến int, nếu tôi viết *arg[N]tôi sẽ có một phao" hơn là " funcphải là một con trỏ tới một hàm dùng này và trả lại điều đó ".

Mục C trên Wikipedia tuyên bố rằng:

Ý tưởng của Ritchie là khai báo các định danh trong các ngữ cảnh giống như cách sử dụng của họ: "khai báo phản ánh việc sử dụng".

... trích dẫn p122 của K & R2, tuy nhiên, tôi không phải ra tay để tìm báo giá mở rộng cho bạn.

Thứ hai, thực sự rất khó để đưa ra một cú pháp khai báo phù hợp khi bạn đang xử lý các mức độ tùy tiện. Ví dụ của bạn có thể hoạt động tốt để thể hiện loại bạn nghĩ ra từ đó, nhưng nó có mở rộng thành một hàm lấy một con trỏ tới một mảng các loại đó và trả lại một số mớ hỗn độn đáng ghét khác không? (Có thể là như vậy, nhưng bạn đã kiểm tra chưa? Bạn có thể chứng minh không? ).

Hãy nhớ rằng, một phần thành công của C là do các trình biên dịch được viết cho nhiều nền tảng khác nhau, và vì vậy tốt hơn là nên bỏ qua một số mức độ dễ đọc vì mục đích làm cho trình biên dịch dễ viết hơn.

Phải nói rằng, tôi không phải là một chuyên gia về ngữ pháp ngôn ngữ hoặc trình biên dịch. Nhưng tôi biết đủ để biết có rất nhiều điều cần biết;)

Rất nhiều điều kỳ lạ của ngôn ngữ C có thể được giải thích bằng cách máy tính làm việc khi nó được thiết kế. Số lượng bộ nhớ lưu trữ rất hạn chế, vì vậy việc giảm thiểu kích thước của các tệp mã nguồn là rất quan trọng . Việc thực hành lập trình từ những năm 70 và 80 là để đảm bảo mã nguồn chứa càng ít ký tự càng tốt và tốt nhất là không có nhận xét mã nguồn quá mức.

Điều này tất nhiên là vô lý ngày nay, với khá nhiều không gian lưu trữ không giới hạn trên các ổ đĩa cứng. Nhưng nó là một phần lý do tại sao C có cú pháp kỳ lạ như vậy nói chung.

Về con trỏ mảng cụ thể, ví dụ thứ hai của bạn phải là int (*p)[10];(vâng cú pháp rất khó hiểu). Có lẽ tôi sẽ đọc nó là "int con trỏ đến mảng mười" ... điều này có ý nghĩa phần nào. Nếu không phải là dấu ngoặc đơn, trình biên dịch sẽ diễn giải nó như là một mảng gồm mười con trỏ, điều này sẽ mang lại cho khai báo một ý nghĩa hoàn toàn khác.

Vì các con trỏ mảng và các con trỏ hàm đều có cú pháp khá tối nghĩa trong C, nên điều hợp lý để làm là loại bỏ sự kỳ lạ. Có lẽ như thế này:

Ví dụ tối nghĩa:

int func (int (*arr_ptr)[10])
{
  return 0;
}

int main()
{
  int array[10];
  int (*arr_ptr)[10]  = &array;
  int (*func_ptr)(int(*)[10]) = &func;

  func_ptr(arr_ptr);
}

Không tối nghĩa, ví dụ tương đương:

typedef int array_t[10];
typedef int (*funcptr_t)(array_t*);


int func (array_t* arr_ptr)
{
  return 0;
}

int main()
{
  int        array[10];
  array_t*   arr_ptr  = &array; /* non-obscure array pointer */
  funcptr_t  func_ptr = &func;  /* non-obscure function pointer */

  func_ptr(arr_ptr);
}

Mọi thứ thậm chí còn khó hiểu hơn nếu bạn đang xử lý các mảng con trỏ hàm. Hoặc tối nghĩa nhất của tất cả chúng: các hàm trả về hàm con trỏ (hữu ích nhẹ). Nếu bạn không sử dụng typedefs cho những thứ đó, bạn sẽ nhanh chóng phát điên.

Nó khá đơn giản: int *pcó nghĩa *plà một int; int a[5]có nghĩa a[i]là một int.

int (*f)(int (*a)[5])

Có nghĩa *flà một hàm, *alà một mảng gồm năm số nguyên, do đó, fmột hàm lấy một con trỏ tới một mảng gồm năm số nguyên và trả về int. Tuy nhiên, trong C, việc truyền một con trỏ tới một mảng là không hữu ích.

C khai báo rất hiếm khi có được phức tạp này.

Ngoài ra, bạn có thể làm rõ bằng cách sử dụng typedefs:

typedef int vec5[5];
int (*f)(vec5 *a);

Tôi nghĩ bạn phải coi * [] là các toán tử được gắn vào một biến. * được viết trước một biến, [] sau.

Hãy đọc biểu thức

int* (*p)[10];

Phần tử trong cùng là p, một biến, do đó

p

có nghĩa là: p là một biến.

Trước biến có một dấu *, toán tử * luôn được đặt trước biểu thức mà nó đề cập đến, do đó,

(*p)

có nghĩa là: biến p là một con trỏ. Không có toán tử () toán tử [] ở bên phải sẽ có quyền ưu tiên cao hơn, nghĩa là

**p[]

sẽ được phân tích thành

*(*(p[]))

Bước tiếp theo là []: vì không có thêm (), [] có quyền ưu tiên cao hơn bên ngoài *, do đó

(*p)[]

có nghĩa là: (biến p là một con trỏ) đến một mảng. Sau đó, chúng tôi có thứ hai *:

* (*p)[]

có nghĩa là: ((biến p là một con trỏ) đến một mảng) của các con trỏ

Cuối cùng, bạn có toán tử int (tên loại), có mức ưu tiên thấp nhất:

int* (*p)[]

nghĩa là: (((biến p là con trỏ) đến một mảng) của con trỏ) thành số nguyên.

Vì vậy, toàn bộ hệ thống dựa trên các biểu thức kiểu với các toán tử và mỗi toán tử có các quy tắc ưu tiên riêng. Điều này cho phép xác định các loại rất phức tạp.

Không quá khó khi bạn bắt đầu suy nghĩ và C không bao giờ là ngôn ngữ rất dễ dàng. Và int*[10]* pthực sự không dễ hơn int* (*p)[10] Và loại k sẽ ở trongint*[10]* p, k;