Приведение указателя функции к другому типу

Я спросил об этой точно такой же проблеме относительно некоторого кода в GLib недавно. (Глеб-это базовая библиотека для проекта GNOME и написана на C.) мне сказали, что все слоты-Н-'signals рамки зависит от него.

во всем коде существует множество примеров приведения от типа (1) до (2):

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

это обычно цепочка через с вызовами, как это:

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

смотрите сами здесь в g_array_sort(): http://git.gnome.org/browse/glib/tree/glib/garray.c

ответы выше подробно и, вероятно, правильно -- если вы сидите в комитете стандартов. Адам и Йоханнес заслуживают похвалы за их хорошо изученные ответы. Однако, в дикой природе, вы найдете этот код работает просто отлично. Спорный вопрос? Да. Рассмотрим это: GLib компилирует/работает / тесты на большом количестве платформ (Linux / Solaris/Windows / OS X) с широким разнообразием компиляторов / компоновщиков / загрузчиков ядра (GCC/CLang/MSVC). К черту стандарты, я думаю.

Я провел некоторое время, думая об этих ответах. Вот мой вывод:

1. если вы пишете библиотеку обратного вызова, это может быть нормально. Будьте бдительны, используйте на свой страх и риск.
2. иначе, не делай этого.

думая глубже после написания этого ответа, я не удивлюсь, если код для компиляторов C использует тот же трюк. И так (большинство/все?) современные компиляторы C загружаются, это означало бы, что трюк безопасен.

более важный вопрос для исследования: может ли кто-нибудь найти платформу/компилятор/компоновщик/загрузчик, где этот трюк делает не работы? Побольше очков для этого. Я уверен, что есть некоторые встроенные процессоры/системы, которые не любят его. Однако для настольных компьютеров (и, вероятно, мобильных/планшетных) этот трюк, вероятно, все еще работает.

дело действительно не в том, что вы можете. Тривиальным решением является

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

хороший компилятор будет генерировать код только для my_callback_helper, если это действительно необходимо, и в этом случае вы были бы рады, что это так.

у вас есть совместимый тип функции, если тип возвращаемого значения и типы параметров совместимы - в основном (это сложнее на самом деле :)). Совместимость такая же, как и "тот же тип", просто более слабая, чтобы позволить иметь разные типы, но все же иметь некоторую форму выражения "эти типы почти одинаковы". Например, в C89 две структуры были совместимы, если они были идентичны, но только их имя было другим. C99, похоже, изменил это. Цитирование из в обоснование документ (настоятельно рекомендуется к прочтению, кстати!):

что сказал-Да строго это неопределенное поведение, потому что ваша функция do_stuff или кто-то другой вызовет вашу функцию с указателем функции, имеющим void* как параметр, но ваша функция имеет несовместимый параметр. Но тем не менее, я ожидаю, что все компиляторы будут компилировать и запускать его без стонов. Но вы можете сделать чище, имея другую функцию, принимая void* (и регистрируя это как функцию обратного вызова) , которая просто вызовет ваш фактический тогда действуй.

поскольку код C компилируется в инструкции, которые вообще не заботятся о типах указателей, вполне нормально использовать код, который вы упоминаете. Вы столкнетесь с проблемами, когда вы запустите do_stuff с вашей функцией обратного вызова и указателем на что-то еще, чем my_struct structure в качестве аргумента.

Я надеюсь, что смогу сделать это яснее, показав, что не будет работать:

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

или...

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

в принципе, вы можете использовать указатели на все, что вам нравится, пока данные продолжайте иметь смысл во время выполнения.

Если вы думаете о том, как работают вызовы функций в C/C++, они нажимают определенные элементы в стеке, переходят в новое местоположение кода, выполняют, а затем открывают стек при возврате. Если указатели на функции описывают функции с одинаковым типом возвращаемого значения и одинаковым числом/размером аргументов, вы должны быть в порядке.

таким образом, я думаю, вы должны быть в состоянии сделать это безопасно.

указатели Void совместимы с другими типами указателей. Это основа того, как malloc и функции mem (memcpy,memcmp) работы. Как правило, в C (а не C++) NULL - это макрос, определенный как ((void *)0).

посмотрите на 6.3.2.3 (пункт 1) в C99:

указатель на void может быть преобразован в или из указателя на любой неполный или тип объекта