Truyền một con trỏ hàm đến một kiểu khác

Giả sử tôi có một hàm chấp nhận một void (*)(void*)con trỏ hàm để sử dụng làm lệnh gọi lại:

void do_stuff(void (*callback_fp)(void*), void* callback_arg);

Bây giờ, nếu tôi có một chức năng như thế này:

void my_callback_function(struct my_struct* arg);

Tôi có thể làm điều này một cách an toàn?

do_stuff((void (*)(void*)) &my_callback_function, NULL);

Tôi đã xem xét câu hỏi này và tôi đã xem xét một số tiêu chuẩn C nói rằng bạn có thể truyền tới 'con trỏ chức năng tương thích', nhưng tôi không thể tìm thấy định nghĩa 'con trỏ chức năng tương thích' nghĩa là gì.

Theo như tiêu chuẩn C có liên quan, nếu bạn truyền một con trỏ hàm đến một con trỏ hàm thuộc kiểu khác và sau đó gọi nó, đó là hành vi không xác định . Xem Phụ lục J.2 (cung cấp thông tin):

Hành vi không được xác định trong các trường hợp sau:

• Con trỏ được sử dụng để gọi một hàm có kiểu không tương thích với kiểu trỏ đến (6.3.2.3).

Phần 6.3.2.3, đoạn 8 đọc:

Một con trỏ đến một chức năng của một kiểu có thể được chuyển đổi thành một con trỏ đến một chức năng của một kiểu khác và quay lại; kết quả sẽ được so sánh bằng con trỏ ban đầu. Nếu một con trỏ được chuyển đổi được sử dụng để gọi một hàm có kiểu không tương thích với kiểu trỏ tới, hành vi đó là không xác định.

Vì vậy, nói cách khác, bạn có thể ép kiểu con trỏ hàm đến một kiểu con trỏ hàm khác, ép kiểu lại và gọi nó, và mọi thứ sẽ hoạt động.

Định nghĩa về tương thích hơi phức tạp. Nó có thể được tìm thấy trong mục 6.7.5.3, đoạn 15:

Để hai kiểu chức năng tương thích, cả hai đều phải chỉ định kiểu trả về tương thích ¹²⁷ .

Hơn nữa, danh sách kiểu tham số, nếu cả hai đều có mặt, sẽ thống nhất về số lượng tham số và cách sử dụng dấu chấm lửng; các tham số tương ứng phải có kiểu tương thích. Nếu một kiểu có danh sách kiểu tham số và kiểu khác được chỉ định bởi trình khai báo hàm không phải là một phần của định nghĩa hàm và chứa danh sách định danh trống, danh sách tham số sẽ không có dấu chấm lửng và kiểu của mỗi tham số sẽ tương thích với loại kết quả từ việc áp dụng các quảng cáo đối số mặc định. Nếu một kiểu có danh sách kiểu tham số và kiểu khác được chỉ định bởi định nghĩa hàm có chứa danh sách định danh (có thể trống), thì cả hai sẽ đồng ý về số lượng tham số, và kiểu của mỗi tham số nguyên mẫu phải tương thích với kiểu là kết quả của việc áp dụng các quảng cáo đối số mặc định cho kiểu của số nhận dạng tương ứng. (Trong việc xác định tính tương thích của kiểu và kiểu kết hợp, mỗi tham số được khai báo với kiểu hàm hoặc kiểu mảng được coi là có kiểu điều chỉnh và mỗi tham số được khai báo với kiểu đủ điều kiện được coi là có phiên bản không đủ điều kiện của kiểu đã khai báo.)

127) Nếu cả hai kiểu hàm đều là '' kiểu cũ '', thì các kiểu tham số sẽ không được so sánh.

Các quy tắc để xác định xem hai loại có tương thích hay không được mô tả trong phần 6.2.7 và tôi sẽ không trích dẫn chúng ở đây vì chúng khá dài, nhưng bạn có thể đọc chúng trên bản nháp của tiêu chuẩn C99 (PDF) .

Quy tắc liên quan ở đây nằm trong mục 6.7.5.1, đoạn 2:

Để hai loại con trỏ tương thích, cả hai đều phải đủ tiêu chuẩn giống nhau và cả hai đều phải là con trỏ tới các loại tương thích.

Do đó, vì a void* không tương thích với a struct my_struct*, một loại con trỏ hàm void (*)(void*)không tương thích với một loại con trỏ hàm void (*)(struct my_struct*), do đó, việc đúc con trỏ hàm về mặt kỹ thuật là hành vi không xác định.

Tuy nhiên, trong thực tế, bạn có thể an toàn với việc truyền con trỏ hàm trong một số trường hợp. Trong quy ước gọi x86, các đối số được đẩy lên ngăn xếp và tất cả các con trỏ đều có cùng kích thước (4 byte trong x86 hoặc 8 byte trong x86_64). Việc gọi một con trỏ hàm dẫn đến việc đẩy các đối số trên ngăn xếp và thực hiện một bước nhảy gián tiếp đến mục tiêu con trỏ hàm và rõ ràng là không có khái niệm về các loại ở cấp mã máy.

Những điều bạn chắc chắn không thể làm:

• Truyền giữa các con trỏ hàm của các quy ước gọi khác nhau. Bạn sẽ làm xáo trộn ngăn xếp và tệ nhất là sụp đổ, tệ nhất là thành công một cách âm thầm với một lỗ hổng bảo mật khổng lồ. Trong lập trình Windows, bạn thường chuyển các con trỏ hàm xung quanh. Win32 hy vọng tất cả các chức năng gọi lại để sử dụng các stdcallquy ước gọi (mà các macro CALLBACK, PASCALvà WINAPItất cả các mở rộng sang). Nếu bạn truyền một con trỏ hàm sử dụng quy ước gọi C chuẩn ( cdecl), thì lỗi sẽ dẫn đến.
• Trong C ++, ép kiểu giữa con trỏ hàm thành viên lớp và con trỏ hàm thông thường. Điều này thường làm cho người mới học C ++. Các hàm thành viên của lớp có một thistham số ẩn , và nếu bạn chuyển một hàm thành viên thành một hàm thông thường, sẽ không có thisđối tượng nào để sử dụng và một lần nữa, nhiều lỗi sẽ dẫn đến.

Một ý tưởng tồi khác đôi khi có thể hoạt động nhưng cũng là hành vi không xác định:

• Truyền giữa con trỏ hàm và con trỏ thông thường (ví dụ: ép kiểu a void (*)(void)thành a void*). Con trỏ hàm không nhất thiết phải có cùng kích thước với con trỏ thông thường, vì trên một số kiến ​​trúc, chúng có thể chứa thêm thông tin ngữ cảnh. Điều này có thể sẽ hoạt động tốt trên x86, nhưng hãy nhớ rằng đó là hành vi không xác định.

Tôi đã hỏi về vấn đề tương tự chính xác này liên quan đến một số mã trong GLib gần đây. (GLib là một thư viện cốt lõi cho dự án GNOME và được viết bằng C.) Tôi đã được thông báo rằng toàn bộ khung ký hiệu của slot'n phụ thuộc vào nó.

Xuyên suốt mã, có rất nhiều trường hợp truyền từ kiểu (1) sang (2):

1. typedef int (*CompareFunc) (const void *a, const void *b)
2. typedef int (*CompareDataFunc) (const void *b, const void *b, void *user_data)

Thông thường chuỗi thông qua các cuộc gọi như thế này:

int stuff_equal (GStuff      *a,
                 GStuff      *b,
                 CompareFunc  compare_func)
{
    return stuff_equal_with_data(a, b, (CompareDataFunc) compare_func, NULL);
}

int stuff_equal_with_data (GStuff          *a,
                           GStuff          *b,
                           CompareDataFunc  compare_func,
                           void            *user_data)
{
    int result;
    /* do some work here */
    result = compare_func (data1, data2, user_data);
    return result;
}

Xem cho chính mình ở đây trong g_array_sort(): http://git.gnome.org/browse/glib/tree/glib/garray.c

Các câu trả lời trên rất chi tiết và có thể đúng - nếu bạn ngồi trong ủy ban tiêu chuẩn. Adam và Johannes xứng đáng được ghi nhận vì những câu trả lời được nghiên cứu kỹ lưỡng của họ. Tuy nhiên, ngoài tự nhiên, bạn sẽ thấy mã này hoạt động tốt. Gây tranh cãi? Đúng. Hãy xem xét điều này: GLib biên dịch / hoạt động / thử nghiệm trên một số lượng lớn nền tảng (Linux / Solaris / Windows / OS X) với nhiều trình biên dịch / liên kết / bộ nạp hạt nhân (GCC / CLang / MSVC). Tôi đoán là các tiêu chuẩn đã chết tiệt.

Tôi đã dành thời gian suy nghĩ về những câu trả lời này. Đây là kết luận của tôi:

1. Nếu bạn đang viết thư viện gọi lại, điều này có thể ổn. Cảnh báo trước - sử dụng có rủi ro của riêng bạn.
2. Khác, đừng làm điều đó.

Suy nghĩ sâu hơn sau khi viết phản hồi này, tôi sẽ không ngạc nhiên nếu mã cho trình biên dịch C sử dụng thủ thuật tương tự. Và vì (hầu hết / tất cả?) Các trình biên dịch C hiện đại đều được khởi động, điều này có nghĩa là thủ thuật là an toàn.

Một câu hỏi quan trọng hơn để nghiên cứu: Ai đó có thể tìm thấy một nền tảng / trình biên dịch / trình liên kết / trình tải ở nơi thủ thuật này không hoạt động không? Bánh brownie chính cho điểm đó. Tôi cá rằng có một số bộ xử lý / hệ thống nhúng không thích nó. Tuy nhiên, đối với máy tính để bàn (và có thể là điện thoại di động / máy tính bảng), thủ thuật này có thể vẫn hoạt động.

Vấn đề thực sự không phải là liệu bạn có thể. Giải pháp tầm thường là

void my_callback_function(struct my_struct* arg);
void my_callback_helper(void* pv)
{
    my_callback_function((struct my_struct*)pv);
}
do_stuff(&my_callback_helper);

Một trình biên dịch tốt sẽ chỉ tạo mã cho my_callback_helper nếu nó thực sự cần thiết, trong trường hợp đó, bạn sẽ rất vui vì nó đã làm được.

Bạn có kiểu hàm tương thích nếu kiểu trả về và kiểu tham số tương thích - về cơ bản (thực tế phức tạp hơn :)). Khả năng tương thích cũng giống như "cùng loại" chỉ lỏng lẻo hơn khi cho phép có nhiều loại khác nhau nhưng vẫn có một số hình thức nói "các loại này gần như giống nhau". Ví dụ, trong C89, hai cấu trúc tương thích nếu chúng giống hệt nhau nhưng chỉ khác tên của chúng. C99 dường như đã thay đổi điều đó. Trích dẫn từ tài liệu lý do c (rất khuyến khích đọc, btw!):

Các khai báo kiểu cấu trúc, liên hợp hoặc kiểu liệt kê trong hai đơn vị dịch khác nhau không chính thức khai báo cùng một kiểu, ngay cả khi văn bản của các khai báo này đến từ cùng một tệp bao gồm, vì bản thân các đơn vị dịch là rời rạc. Do đó, Tiêu chuẩn quy định các quy tắc tương thích bổ sung cho các loại như vậy, để nếu hai khai báo như vậy đủ giống nhau thì chúng sẽ tương thích.

Điều đó nói - vâng, đây là hành vi không xác định, bởi vì hàm do_stuff của bạn hoặc người khác sẽ gọi hàm của bạn bằng một con trỏ hàm có void*tham số, nhưng hàm của bạn có một tham số không tương thích. Nhưng tuy nhiên, tôi hy vọng tất cả các trình biên dịch đều có thể biên dịch và chạy nó mà không phải than vãn. Nhưng bạn có thể làm sạch hơn bằng cách có một hàm khác sử dụng một void*(và đăng ký đó làm hàm gọi lại) mà sau đó sẽ gọi hàm thực của bạn.

Vì mã C biên dịch thành hướng dẫn không quan tâm chút nào đến các loại con trỏ, nên sử dụng mã bạn đề cập là khá tốt. Bạn sẽ gặp sự cố khi chạy do_stuff với hàm gọi lại của mình và con trỏ đến một thứ khác rồi đến cấu trúc my_struct làm đối số.

Tôi hy vọng tôi có thể làm cho nó rõ ràng hơn bằng cách hiển thị những gì sẽ không hoạt động:

int my_number = 14;
do_stuff((void (*)(void*)) &my_callback_function, &my_number);
// my_callback_function will try to access int as struct my_struct
// and go nuts

hoặc là...

void another_callback_function(struct my_struct* arg, int arg2) { something }
do_stuff((void (*)(void*)) &another_callback_function, NULL);
// another_callback_function will look for non-existing second argument
// on the stack and go nuts

Về cơ bản, bạn có thể truyền con trỏ tới bất kỳ thứ gì bạn thích, miễn là dữ liệu tiếp tục có ý nghĩa tại thời điểm chạy.

Nếu bạn nghĩ về cách hoạt động của các lệnh gọi hàm trong C / C ++, chúng đẩy một số mục nhất định lên ngăn xếp, nhảy đến vị trí mã mới, thực thi, sau đó trả lại ngăn xếp. Nếu con trỏ hàm của bạn mô tả các hàm có cùng kiểu trả về và cùng số lượng / kích thước đối số, bạn sẽ không sao.

Vì vậy, tôi nghĩ bạn sẽ có thể làm như vậy một cách an toàn.

Con trỏ rỗng tương thích với các loại con trỏ khác. Nó là xương sống của cách hoạt động của malloc và các hàm mem ( memcpy, memcmp). Thông thường, trong C (chứ không phải C ++) NULLlà một macro được định nghĩa là ((void *)0).

Xem 6.3.2.3 (Mục 1) trong C99:

Một con trỏ đến void có thể được chuyển đổi thành hoặc từ một con trỏ thành bất kỳ loại đối tượng hoặc không hoàn chỉnh nào