Transmitindo um ponteiro de função para outro tipo

Digamos que eu tenha uma função que aceita um void (*)(void*)ponteiro de função para uso como retorno de chamada:

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

Agora, se eu tiver uma função como esta:

void my_callback_function(struct my_struct* arg);

Posso fazer isso com segurança?

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

Eu olhei para esta questão e olhei para alguns padrões C que dizem que você pode converter para 'ponteiros de função compatíveis', mas não consigo encontrar uma definição do que significa 'ponteiro de função compatível'.

No que diz respeito ao padrão C, se você lançar um ponteiro de função para um ponteiro de função de um tipo diferente e depois chamá-lo, é um comportamento indefinido . Consulte o Anexo J.2 (informativo):

O comportamento é indefinido nas seguintes circunstâncias:

• Um ponteiro é usado para chamar uma função cujo tipo não é compatível com o tipo apontado (6.3.2.3).

Seção 6.3.2.3, parágrafo 8 diz:

Um ponteiro para uma função de um tipo pode ser convertido em um ponteiro para uma função de outro tipo e vice-versa; o resultado deve ser igual ao ponteiro original. Se um ponteiro convertido é usado para chamar uma função cujo tipo não é compatível com o tipo apontado, o comportamento é indefinido.

Em outras palavras, você pode lançar um ponteiro de função para um tipo de ponteiro de função diferente, convertê-lo novamente e chamá-lo, e tudo vai funcionar.

A definição de compatível é um tanto complicada. Pode ser encontrado na seção 6.7.5.3, parágrafo 15:

Para que dois tipos de função sejam compatíveis, ambos devem especificar os tipos de retorno compatíveis ¹²⁷ .

Além disso, as listas de tipo de parâmetro, se ambas estiverem presentes, devem concordar no número de parâmetros e no uso do terminador de reticências; os parâmetros correspondentes devem ter tipos compatíveis. Se um tipo tem uma lista de tipo de parâmetro e o outro tipo é especificado por um declarador de função que não faz parte de uma definição de função e que contém uma lista de identificadores vazia, a lista de parâmetros não deve ter um terminador de reticências e o tipo de cada parâmetro deve ser compatível com o tipo que resulta da aplicação das promoções de argumento padrão. Se um tipo tem uma lista de tipo de parâmetro e o outro tipo é especificado por uma definição de função que contém uma lista de identificadores (possivelmente vazia), ambos devem concordar no número de parâmetros, e o tipo de cada parâmetro de protótipo deve ser compatível com o tipo que resulta da aplicação das promoções do argumento padrão ao tipo do identificador correspondente. (Na determinação da compatibilidade de tipo e de um tipo composto, cada parâmetro declarado com tipo de função ou array é considerado como tendo o tipo ajustado e cada parâmetro declarado com tipo qualificado é considerado como tendo a versão não qualificada de seu tipo declarado.)

127) Se ambos os tipos de função forem do '' estilo antigo '', os tipos de parâmetro não são comparados.

As regras para determinar se dois tipos são compatíveis estão descritas na seção 6.2.7 e não as citarei aqui, pois são bastante extensas, mas você pode lê-las no rascunho do padrão C99 (PDF) .

A regra relevante aqui está na seção 6.7.5.1, parágrafo 2:

Para que dois tipos de ponteiros sejam compatíveis, ambos devem ser qualificados de forma idêntica e ambos devem ser ponteiros para tipos compatíveis.

Portanto, como a void* não é compatível com a struct my_struct*, um ponteiro de função do tipo void (*)(void*)não é compatível com um ponteiro de função do tipo void (*)(struct my_struct*), portanto, essa conversão de ponteiros de função é tecnicamente um comportamento indefinido.

Na prática, entretanto, você pode se safar com segurança lançando ponteiros de função em alguns casos. Na convenção de chamada x86, os argumentos são colocados na pilha e todos os ponteiros têm o mesmo tamanho (4 bytes em x86 ou 8 bytes em x86_64). Chamar um ponteiro de função se resume a empurrar os argumentos na pilha e fazer um salto indireto para o destino do ponteiro de função e, obviamente, não há noção de tipos no nível do código de máquina.

Coisas que você definitivamente não pode fazer:

• Converta entre ponteiros de função de diferentes convenções de chamada. Você bagunçará a pilha e, na melhor das hipóteses, travará; na pior, terá sucesso silenciosamente com uma enorme brecha de segurança. Na programação do Windows, você costuma passar ponteiros de função. Win32 espera que todas as funções de retorno de chamada para usar a stdcallconvenção de chamada (que as macros CALLBACK, PASCALe WINAPItodos expandir a). Se você passar um ponteiro de função que usa a convenção de chamada C padrão ( cdecl), o resultado será ruim.
• Em C ++, converta entre ponteiros de função de membro de classe e ponteiros de função regular. Isso muitas vezes atrapalha novatos em C ++. As funções de membro de classe têm um thisparâmetro oculto e, se você converter uma função de membro em uma função regular, não haverá nenhum thisobjeto a ser usado e, novamente, muita maldade resultará.

Outra má ideia que às vezes pode funcionar, mas também é um comportamento indefinido:

• Conversão entre ponteiros de função e ponteiros regulares (por exemplo, conversão de a void (*)(void)para a void*). Ponteiros de função não são necessariamente do mesmo tamanho que ponteiros regulares, pois em algumas arquiteturas eles podem conter informações contextuais extras. Isso provavelmente funcionará bem no x86, mas lembre-se de que é um comportamento indefinido.

Eu perguntei sobre esse mesmo problema em relação a algum código no GLib recentemente. (GLib é uma biblioteca central para o projeto GNOME e escrita em C.) Disseram-me que todo o framework slots'n'signals depende disso.

Em todo o código, existem inúmeras instâncias de conversão do tipo (1) a (2):

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

É comum fazer encadeamento com chamadas como esta:

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

Veja você mesmo aqui em g_array_sort(): http://git.gnome.org/browse/glib/tree/glib/garray.c

As respostas acima são detalhadas e provavelmente corretas - se você fizer parte do comitê de padrões. Adam e Johannes merecem crédito por suas respostas bem pesquisadas. No entanto, lá fora, você descobrirá que este código funciona muito bem. Controverso? Sim. Considere o seguinte: GLib compila / funciona / testa em um grande número de plataformas (Linux / Solaris / Windows / OS X) com uma ampla variedade de compiladores / linkers / carregadores de kernel (GCC / CLang / MSVC). Padrões que se danem, eu acho.

Passei algum tempo pensando nessas respostas. Aqui está minha conclusão:

1. Se você estiver escrevendo uma biblioteca de retorno de chamada, pode estar tudo bem. Caveat emptor - use por sua própria conta e risco.
2. Senão, não faça isso.

Pensando mais profundamente depois de escrever esta resposta, não ficaria surpreso se o código para compiladores C usasse esse mesmo truque. E uma vez que (a maioria / todos?) Os compiladores C modernos são inicializados, isso implicaria que o truque é seguro.

Uma questão mais importante para pesquisar: alguém pode encontrar uma plataforma / compilador / linker / carregador onde esse truque não funcione? Pontos principais de brownie para aquele. Aposto que existem alguns processadores / sistemas embarcados que não gostam. No entanto, para a computação desktop (e provavelmente celular / tablet), esse truque provavelmente ainda funciona.

A questão realmente não é se você pode. A solução trivial é

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

Um bom compilador só gerará código para my_callback_helper se for realmente necessário, caso em que você ficaria feliz por isso.

Você tem um tipo de função compatível se o tipo de retorno e os tipos de parâmetro forem compatíveis - basicamente (é mais complicado na realidade :)). Compatibilidade é o mesmo que "mesmo tipo", apenas mais frouxa para permitir ter tipos diferentes, mas ainda tem alguma forma de dizer "esses tipos são quase iguais". No C89, por exemplo, duas estruturas eram compatíveis se fossem idênticas, mas apenas o nome fosse diferente. C99 parece ter mudado isso. Citando o documento de justificativa c (leitura altamente recomendada, aliás!):

Declarações de tipo de estrutura, união ou enumeração em duas unidades de tradução diferentes não declaram formalmente o mesmo tipo, mesmo se o texto dessas declarações vier do mesmo arquivo de inclusão, uma vez que as unidades de tradução são elas próprias disjuntas. A Norma, portanto, especifica regras de compatibilidade adicionais para tais tipos, de modo que se duas dessas declarações forem suficientemente semelhantes, elas serão compatíveis.

Dito isso - sim, estritamente, este é um comportamento indefinido, porque sua função do_stuff ou outra pessoa irá chamar sua função com um ponteiro de função tendo void*como parâmetro, mas sua função tem um parâmetro incompatível. Mesmo assim, espero que todos os compiladores o compilem e executem sem reclamar. Mas você pode fazer mais limpo tendo outra função tomando uma void*(e registrando-a como função de retorno de chamada) que apenas chamará sua função real.

Como o código C compila para uma instrução que não se preocupa com os tipos de ponteiro, é muito bom usar o código que você mencionou. Você teria problemas quando executasse do_stuff com sua função de retorno de chamada e apontasse para algo diferente da estrutura my_struct como argumento.

Espero poder deixar isso mais claro, mostrando o que não funcionaria:

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

ou...

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

Basicamente, você pode lançar ponteiros para o que quiser, contanto que os dados continuem a fazer sentido em tempo de execução.

Se você pensar sobre como as chamadas de função funcionam em C / C ++, elas colocam certos itens na pilha, saltam para o novo local do código, executam e, em seguida, devolvem a pilha. Se seus ponteiros de função descrevem funções com o mesmo tipo de retorno e o mesmo número / tamanho de argumentos, você deve estar bem.

Portanto, acho que você deve ser capaz de fazer isso com segurança.

Os ponteiros nulos são compatíveis com outros tipos de ponteiros. É a espinha dorsal de como malloc e as funções mem ( memcpy, memcmp) funcionam. Normalmente, em C (em vez de C ++) NULLé uma macro definida como ((void *)0).

Olhe para 6.3.2.3 (Item 1) em C99:

Um ponteiro para o vazio pode ser convertido de ou para um ponteiro para qualquer tipo de objeto ou incompleto