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

Прошло некоторое время, но не должен ли код для назначения указателя функции быть:

//this is okay
destructor destructor1 = &destructorFoo1;

//this should throw a compilation error!
destructor destructor2 = &destructorFoo2;

Обновлено:

Ладно, я ушел и посмотрел на это поближе.

Если я изменю объявление указателя функции на использование const Foo* p, а не const void* obj, чтобы мы не полагались на приведение, чтобы скрыть несовместимость между void* и Foo*, я получаю предупреждение с настройками компилятора по умолчанию.

Затем, приведя destroyFoo2 к (деструктору), вы затем скроете это предупреждение, заставив компилятор рассматривать функцию как этот тип.

Я предполагаю, что это подчеркивает подводные камни кастинга.

Я проверил это, используя следующий код:

typedef struct Foo
{
    int a;
} Foo;

typedef void (*destructor)(const Foo* p, const void* context);


void destroyFoo1(const Foo* p, const void* context);
void destroyFoo1(const Foo* p, const void* context) 
{
   free((void*)p);
   if (*((int*)context) == 0) {
       printf("hello world\n");
   }
}
void destroyFoo2(const Foo* p);
void destroyFoo2(const Foo* p) 
{
    free((void*)p);
}
int main(void)
{
    //this is okay
    destructor destructor1 =  destroyFoo1;
    //this triggers a warning
    destructor destructor2 = destroyFoo2;
    //This doesn't generate a warning
    destructor destructor3 = (destructor)destroyFoo2;

}

Хорошо, я думаю, что понял это, но это не так просто.

Прежде всего, проблема заключается в том, что CHECK_IF_FUNCTION_RETURNS_VOID_AND_REQUIRE_2_VOID_POINTERS необходимо сравнивать во время компиляции 2 подписи: входную (данную из указателя входной функции, например, destroyFoo1) и базовую (то есть подпись типа destructor): если мы реализуем метод это делает это, мы можем проверить, являются ли 2 подписи «совместимыми» или нет.

Мы делаем это, используя препроцессор C. Основная идея заключается в том, что для каждой функции, которую мы хотели бы использовать в качестве destructor, определен макрос. CHECK_IF_FUNCTION_RETURNS_VOID_AND_REQUIRE_2_VOID_POINTERS также будет макросом, который просто генерирует имя макроса на основе сигнатуры типа destructor: если имя макроса, сгенерированное в CHECK_IF_FUNCTION_RETURNS_VOID_AND_REQUIRE_2_VOID_POINTERS, существует, мы предполагаем, что указатель функции совместим с destructor, и мы приводим к нему. В противном случае мы выдаем ошибку компиляции. Поскольку нам нужно определение макроса для каждой функции, которую мы хотим использовать в качестве деструктора, это может быть дорогостоящим решением в огромных кодовых базах.

Примечание. Реализация зависит от GCC (в ней используются варианты ## и _Pragma, но я думаю, что ее можно легко портировать и на некоторые другие компиляторы).

Так, например:

#define FUNCTION_POINTER_destructor_void_destroyFoo1_voidConstPtr_voidConstPtr 1
void destroyFoo1(const Foo* p, const void* context);

Значение макроса — это просто постоянное число. Что важно, так это имя макроса, которое имеет четко определенную структуру. Соглашение, которое вы используете, не имеет значения, просто выберите и придерживайтесь одного из них. Здесь я использовал следующее соглашение:

//macro (1)
"FUNCTION_POINTER_" typdefName "_" returnType "_" functionName "_" typeparam1 "_" typeparam2 ...

Теперь мы собираемся определить макрос, который проверяет, совпадают ли две подписи. Чтобы помочь нам, мы используем проект Р99. Мы будем использовать несколько макросов из проекта, поэтому вы можете реализовать такие макросы самостоятельно, если не хотите на них полагаться:

#define CHECK_IF_FUNCTION_RETURNS_VOID_AND_REQUIRE_2_VOID_POINTERS(functionName) \
    _ENSURE_FUNCTION_POINTER(1, destructor, void, functionName, voidConstPtr, voidConstPtr)

#define _ENSURE_FUNCTION_POINTER(valueToCheck, castTo, expectedReturnValue, functionName, ...) \
        P99_IF_EQ(valueToCheck, _GET_FUNCTION_POINTER_MACRO(castTo, expectedReturnValue, functionName, ## __VA_ARGS__)) \
            ((castTo)(functionName)) \
            (COMPILE_ERROR())

#define COMPILE_ERROR() _Pragma("GCC error \"function pointer casting error!\"")

Входными данными макроса является значение макроса (1) для проверки (т. е. 1 в данном случае значение из макроса функции), typedef, по которому мы хотим проверить (castTo), тип возвращаемого значения, который мы ожидаем, что functionName будет иметь и functionName, переданный пользователем CHECK_IF_FUNCTION_RETURNS_VOID_AND_REQUIRE_2_VOID_POINTERS (например, destroyFoo1 или destroyFoo2). Variadic — это типы каждого параметра. Эти параметры должны быть такими же, как в (1): мы пишем voidConstPtr, потому что мы не можем использовать const void* в имени макроса.

_GET_FUNCTION_POINTER_MACRO генерирует макрос, связанный с подписью, которую мы ожидаем от functionName:

#define _DEFINE_FUNCTION_POINTER_OP(CONTEXT, INDEX, CURRENT, NEXT) P99_PASTE(CURRENT, NEXT)
#define _DEFINE_FUNCTION_POINTER_FUNC(CONTEXT, CURRENT, INDEX) P99_PASTE(_, CURRENT)

#define _GET_FUNCTION_POINTER_MACRO(functionPointerType, returnValue, functionName, ...) \
    P99_PASTE(FUNCTION_POINTER, _, functionPointerType, _, returnValue, _, functionName, P99_FOR(, P99_NARG(__VA_ARGS__), _DEFINE_FUNCTION_POINTER_OP, _DEFINE_FUNCTION_POINTER_FUNC, ## __VA_ARGS__))

//example
_GET_FUNCTION_POINTER_MACRO(destructor, void, destroyFoo2, voidConstPtr, voidConstPtr)
//it generates
FUNCTION_POINTER_destructor_void_destroyFoo2_voidConstPtr_voidConstPtr

Так, например:

#define FUNCTION_POINTER_destructor_void_destroyFoo1_voidConstPtr_voidConstPtr 1
void destroyFoo1(const Foo* p, const void* context) 
{
   free((void*)p);
   if (*((int*)context) == 0) {
       printf("hello world\n");
   }
}

void destroyFoo2(const Foo* p) 
{
    free((void*)p);
}
int main(void)
{
    //this will work:
    //FUNCTION_POINTER_destructor_void_destroyFoo1_voidConstPtr_voidConstPtr 
    //macro exist and is equal to 1
    destructor destructor1 =  CHECK_IF_FUNCTION_RETURNS_VOID_AND_REQUIRE_2_VOID_POINTERS(destroyFoo1);

    //this raise a compile error:
    //FUNCTION_POINTER_destructor_void_destroyFoo2_voidConstPtr_voidConstPtr
    //does not exist (or exists but its value is not 1)
    destructor destructor2 = CHECK_IF_FUNCTION_RETURNS_VOID_AND_REQUIRE_2_VOID_POINTERS(destroyFoo2);
}

Важные заметки

на самом деле voidConstPtr или даже void в имени макроса — это просто строки. Все бы работало, даже если бы вы заменили void на helloWorld. Они просто следуют условности.

Последнее, что нужно понять, это условие, реализованное P99_IF_EQ в _ENSURE_FUNCTION_POINTER: если вывод _GET_FUNCTION_POINTER_MACRO является существующим макросом, препроцессор автоматически заменит его своим значением, в противном случае имя макроса останется прежним; если макрос заменен на 1 (сгенерированный макрос _GET_FUNCTION_POINTER_MACRO существует и равен 1), мы будем считать, что это достигается только потому, что макрос, определенный разработчиком (1), и мы предполагаем, что functionName соответствует destructor. В противном случае мы выдадим ошибку времени компиляции.