Ponteiro para função

[joubet]

Ponteiros para Funções

Suponha, que eu queira passar uma função como argumento de uma função (ponteiro para funções), como fazer ?

Tendo por base a forma geral:

tipo_de_retorno (*nome_do_ponteiro)(declaração_de_parâmetros);

Recebi de um colega, o código abaixo, mas achei o código muito complicado. Ao termino do código faço alguns questionamentos, mas desde já pergunto se tem como simplificar a passagem de função como argumento de função ?

#include <stdio.h>
#include <stdlib.h>
void EscreveTexto( int (*func)(char*) );
int Texto( char*Texto );
int main ()

{

   int (*p)(char*); /* Cria ponteiro para a função*/

   p = Texto; /* Atribui o nome da função*/

   EscreveTexto( p ); 
   /* Passa ponteiro para a função como referencia*/
   system ("pause");
   return 0;

}

void EscreveTexto( int (*func)(char*) )

{
   int Retorno = func("Este texto foi passado para a função!"); 
   /* Executa função que foi passada como referencia */
   printf("Este é o retorno da função: %d\n", Retorno );
   /* Imprime valor de retorno da função*/
   
   return;
}

int Texto( char*Texto )
{
   printf("%s\n", Texto );
   
   return ( 123 );   
} 

Gostaria de entender melhor a sintaxe das seguintes linhas:

a) int (*p)(char*)

Na linha a), parece-me que foi definido o tipo de retorno da função, um ponteiro para receber a função,*p, e um outro ponteiro que não está muito claro,char*. Pela sintaxe acima, seria o parâmetro ou possíveis paramentos da função. Favor comentar minha interpretação

p = Texto

Aqui p parece receber uma função, não faz menção a nenhum parâmetro da função, que seria char* Aqui já estou achando estranho. Favor comente.

c) EscreveTexto( p )

Aqui estou entendendo, que a função EscreveTexto está recebendo a função Texto por meio do ponteiro p.

d) void EscreveTexto( int (*func)(char*) )

Aqui seria a função EscreveTexto, propriamente dita, que receberia a função Texto. Estou presumindo, que func, corresponda a função Texto, atribuída a p, mas uma fez não me está claro o char* . Favor comentar.

e) int Texto( char*Texto )

Aqui para mim, está muito confuso, pois parece, que a função Texto está passando a si própria como argumento dela mesma. Esta estranho. Favor comentar.

Obrigado.

[EduardoS]

Antes de qualquer coisa, considere que ao declarar uma função você declara uma constante, em um:

int teste()
{
return 0;
}

O compilador joga todo esse código em alguma parte do programa e cria uma constante "teste" com o endereço desse código, o operador parenteses "()" passa a execução do programa para o endereço apontado pela constante (ou variavel, porque não?), agora sobre suas dúvidas.

Na linha a), parece-me que foi definido o tipo de retorno da função, um ponteiro para receber a função,*p, e um outro ponteiro que não está muito claro,char*. Pela sintaxe acima, seria o parâmetro ou possíveis paramentos da função. Favor comentar minha interpretação

Essa linha declarou uma variavel que é um ponteiro para uma função... Como essa:

int teste(char* valor);

portanto:

int (*p) (char*)

O tipo de retorno

Uma variavel ponteiro, que pode receber o ponteiro para uma funcção, repare que se tivesse algum nome no lugar de (*p) estaria declarando uma função

Os parâmetros, se tivesse mais eles seriam separados por virgula

Aqui p parece receber uma função, não faz menção a nenhum parâmetro da função, que seria char* Aqui já estou achando estranho. Favor comente.

"p" recebe o endereço da função, "Texto" é uma constante, veja o início da mensagem.

Aqui estou entendendo, que a função EscreveTexto está recebendo a função Texto por meio do ponteiro p.

O endereço dela.

Aqui seria a função EscreveTexto, propriamente dita, que receberia a função Texto. Estou presumindo, que func, corresponda a função Texto, atribuída a p, mas uma fez não me está claro o char* . Favor comentar.

Ele esta declarando um parâmetro da função EscreveTexto, é a mesma coisa que o item a), e func é apenas o nome desse parâmetro.

Aqui para mim, está muito confuso, pois parece, que a função Texto está passando a si própria como argumento dela mesma. Esta estranho. Favor comentar.

O primeiro Texto é o nome da função, o segundo o nome do parâmetro que é do tipo char*, o parâmetro não é do tipo função, o autor foi um pouco infeliz na escolha dos nomes.

[joubet]

Fiz algumas experiências com base em sua resposta, e agora que a coisa esta mais clara, gostaria de entender alguns outros pontos:

f) Antes, gostaria de entender, sua explanação inicial:

Antes de qualquer coisa, considere que ao declarar uma função você declara uma constante, em um:......

Como assim ?

g) na linha:

p = Texto; /* Atribui a função texto ao ponteiro p*/

por que não posso declarar p=Texto();

h) porque a linha

printf("Este é o retorno da função: %d\n", Retorno );

retorna 123, não deveria retornar o texto passado diretamente ?

O texto propriamente dito, é passado pelo argumento da função Texto.

Geralmente, quando atribuo uma função a uma variável, a variável guarda o “resultado” da função, não o que return retorna.

i) Se é a função Texto(), que é a que exibi o texto propriamente dito, por que ela foi declarada com o tipo de retorno int , e não char ?

J) fiz a seguinte alteração, para poder passar dois argumentos:

void EscreveTexto( int (*func)(char*,int*) );

int Texto( char*argtxt, int*num );

func("Este texto foi passado para a função!",11);

int Texto( char*argtxt,*num )
{
   printf("%s\n", argtxt );
   printf("%d\n", num );
   return (0);    
}

O correram os seguintes erros:

C:\Meus documentos\funcarg.c In function `EscreveTexto':

24 C:\Meus documentos\funcarg.c [Warning] passing arg 2 of pointer to function makes pointer from integer without a cast

At top level:

32 C:\Meus documentos\funcarg.c syntax error before '*' token

C:\Meus documentos\funcarg.c In function `Texto':

33 C:\Meus documentos\funcarg.c number of arguments doesn't match prototype

4 C:\Meus documentos\funcarg.c prototype declaration

34 C:\Meus documentos\funcarg.c `argtxt' undeclared (first use in this function)

(Each undeclared identifier is reported only once

for each function it appears in.)

35 C:\Meus documentos\funcarg.c `num' undeclared (first use in this function)

O que está errado ?

Obrigado

[EduardoS]

Fiz algumas experiências com base em sua resposta, e agora que a coisa esta mais clara, gostaria de entender alguns outros pontos:

f) Antes, gostaria de entender, sua explanação inicial:

Como assim ?

g) na linha:

p = Texto; /* Atribui a função texto ao ponteiro p*/

por que não posso declarar p=Texto();

Falei da constante para facilitar o entendimento, vamos la:

Na hora de compilar uma função "int teste(){return 3);" o compilador vai jogar todas as instruções dessa função em alguma parte do programa, ele não vai reescrever essa função toda vez que alguem chamar ela (algumas podem ser gigantes!), ao invés disso ele vai criar uma constante "teste" que contem o endereço de onde ele jogou todas aquelas instruções, assim cada vez que alguem chamar "teste" ele tera o endereço das instruções (da função em si).

O compilador entende os parenteses "()" como sendo um operador, da mesma forma que o "*", "++", etc, e a operação que ele vai fazer é transferir a execução do programa para o endereço na variavel ou constante antes do operador (ele vai chamar a função), assim se ele encontrar "teste();" não interessa se "teste" é uma variavel ou constante, ele vai chamar o valor/endereço contido nele, se ele encontrar "i = teste;" ele vai atrivuir a i o valor/endereço contido contido em "teste".

h) porque a linha

printf("Este é o retorno da função: %d\n", Retorno );

retorna 123, não deveria retornar o texto passado diretamente ?

O texto propriamente dito, é passado pelo argumento da função Texto.

Não, a função "Texto()" recebe um parâmetro *char e imprime ele, mas o retorno não tem nadaa ver com isso, ele simplesmente retorna 123, veja o "return (123);" no final daquela função.

Geralmente, quando atribuo uma função a uma variável, a variável guarda o “resultado” da função, não o que return retorna.

Quando você atribui uma função a uma variavel (fazendo "i = func;" sem os parenteses, veja o inicio do post) a variavel guarda o endereço da função, quando você atribui a uma variavel o resultado da função (fazendo "i = func();"), a variavel guarda o que o return retornou (ficou confuso?).

i) Se é a função Texto(), que é a que exibi o texto propriamente dito, por que ela foi declarada com o tipo de retorno int , e não char ?

Porque ela retorna 123 que é um int e se chama texto (creio eu) porque imprime o texto que recebeu como parâmetro na tela.

J) fiz a seguinte alteração, para poder passar dois argumentos:

void EscreveTexto( int (*func)(char*,int*) );

int Texto( char*argtxt, int*num );

func("Este texto foi passado para a função!",11);

int Texto( char*argtxt,*num )
{
   printf("%s\n", argtxt );
   printf("%d\n", num );
   return (0);    
}

O correram os seguintes erros:

O que está errado ?

Aqui "int Texto( char*argtxt,*num )" faltou o tipo do segundo parâmetro, deveria ser "int Texto( char*argtxt,int*num )" (pela lista de erros acredito que seja linha 32).

[joubet]

Ok.

Fiz a correção no ponto que você apontou, e aproveitei, para alterar a função EcreveTexto para:

void EscreveTexto( int (*func)(char*,int*) )

{
   func("Este texto foi passado para a função!",11); 
   /* Executa função que foi passada como referencia */
   
   return;

Ao recompilar o programa, recebi o seguinte erro:

C:\Meus documentos\funcarg.c In function `EscreveTexto':

24 C:\Meus documentos\funcarg.c [Warning] passing arg 2 of pointer to function makes pointer from integer without a cast

Ao ler a mensagem de erro, não entendi porque reclamava do argumento. Afinal, o argumento da função a ser passada e de seus dois parâmetros estão presentes. Tive o cuidado de verificar, se o protótipo estava diferente, mas estava Ok. O que está errado agora ?

E aproveito para perguntar: qual seria uma aplicação prática e real de se passar função como argumento de função. O com base somente no exemplo acima, acho muito esforço para pouca coisa. Isso deve ter uma aplicação mais útil, não ?

Obrigado.

[EduardoS]

Ok.

Fiz a correção no ponto que você apontou, e aproveitei, para alterar a função EcreveTexto para:

void EscreveTexto( int (*func)(char*,int*) )

{
   func("Este texto foi passado para a função!",11); 
   /* Executa função que foi passada como referencia */
   
   return;

Ao recompilar o programa, recebi o seguinte erro:

Ao ler a mensagem de erro, não entendi porque reclamava do argumento. Afinal, o argumento da função a ser passada e de seus dois parâmetros estão presentes. Tive o cuidado de verificar, se o protótipo estava diferente, mas estava Ok. O que está errado agora ?

O segundo parâmetro é um int* e você passou um int, altere a declaração para:

void EscreveTexto( int (*func)(char*,int))

E aproveito para perguntar: qual seria uma aplicação prática e real de se passar função como argumento de função. O com base somente no exemplo acima, acho muito esforço para pouca coisa. Isso deve ter uma aplicação mais útil, não ?

Callbacks por exemplo, procure no google, exemplo é o que não falta.

[joubet]

Fiz alteração que você sugeriu:

void EscreveTexto( int (*func)(char*,int))

Na função, no protótipo, e na linha

int (*p)(char*,int);

tive a seguinte mensagem de erro:

C:\Meus documentos\funcarg.c In function `main':

12 C:\Meus documentos\funcarg.c [Warning] assignment from incompatible pointer type

Se eu alterar somente a linha que você sugeriu, e o protótipo, terei a seguinte mensagem de erro:

C:\Meus documentos\funcarg.c In function `main':

14 C:\Meus documentos\funcarg.c [Warning] passing arg 1 of `EscreveTexto' from incompatible pointer type

O que me chamou atenção, foi não precisar declarar o segundo parâmetro da função como pontoneiro e o primeiro sim. O que não estou vendo ?

Qual o conceito de “Callbacks” ? poderia citar outros tipos de aplicação ?

Obrigado

[EduardoS]

Desculpe Joubet, esqueci de avisar que era preciso fazer essa alteração nas demais partes do código que dependiam desse tipo.

O que me chamou atenção, foi não precisar declarar o segundo parâmetro da função como pontoneiro e o primeiro sim. O que não estou vendo ?

O primeiro parâmetro é um texto, ou melhor, um ponteiro para uma sequência de bytes, o segundo apenas um inteiro.

Qual o conceito de “Callbacks” ? poderia citar outros tipos de aplicação ?

Imagine que em alguma parte do seu programa você comece a ler um arquivo do disco, isso é um processo demorado e sera feito pelo DMA, o processador esta livre e pode continuar com outras tarefas, então por que esperar ele ler o arquivo todo antes de continuar? Ele pode ficar lendo enquanto os eu programa faz outras coisas, ok, tem uma dll que faz isso, mas como saber quando o arquivo já estiver lido?

Callbacks, ao chamar a função que le o arquivo passe para ela o ponteiro de uma outra função no seu programa que deve ser chamada quando o arquivo já tiver sido lido, assim o seu programa sera avisado que o arquivo ta pronto.

Outra aplicação são as DLLs do Windows, você pode chamar alguma função delas durante a execução do programa, o Windows possui algumas funções que permitem você carregar uma DLL na memória e pegar o endereço de alguma função específica.

[joubet]

:palmas:

OK.

Com base no que você disse, tirei todos os indicadores de ponteiro, a partir dos segundos paramentos das funções e da definição de ponteiro para função:

void EscreveTexto( int (*func)(char*,int) );
int Texto( char*argtxt, int num );
int (*p)(char*,int);

E deu certo. Pergunto: é regra na declaração de ponteiros para função, declarar, sempre, o parâmetro da função e o primeiro parâmetro como ponteiro e os próximos argumentos como tipo comum ? por que é desse jeito ?

Estou perguntando, porque coloquei um terceiro parâmetro para a função tipo char, e tive que declarar como ponteiro. Quais outros tipos tem que ser declarados como ponteiro e quando, é sempre o primeiro parâmetro ? deu certo

Ex:

 void EscreveTexto( int (*func)(char*,int, char*) );

Obrigado

[EduardoS]

Os parâmetros não precisam ser ponteiros... Basta que os parâmetros passados e os parâmetros da função que você pegar o ponteiro sejam todos compatíveis.

Todos os exemplos a seguir são validos se a regra acima for observada:

int (*p)(int, int);
int (*e)(int*, int);
int (*a)(int, int*);
int (*(int*, int*);

[joubet]

Você agora me pegou de surpresa:

Os parâmetros não precisam ser ponteiros... Basta que os parâmetros passados e os parâmetros da função que você pegar o ponteiro sejam todos compatíveis

Como assim compatíveis ? Pelo que entendi de seu exemplo, compatível, quer dizer, que os parâmetros da função passada como ponteiro para função, devem ser sempre do mesmo tipo, e a função propriamente dita, deve ser sempre passada como ponteiro.

Fiz:

void EscreveTexto( int (*func)(char, int*, char) )

Deu uma série de erros.

Também fiz:

void EscreveTexto( int (*func)(char*, int*, char*) )

Também deu erro.

Voltei para:

void EscreveTexto( int (*func)(char*, int, char*) )

Deu certo.

O que me faz perguntar: Se só posso abrir mão de ponteiros para parâmetros do mesmo tipo, como saber quando usar ponteiros ou não com tipos diferentes ? as três linhas acima foram escritas com base na tentativa e erro.

Obrigado

[EduardoS]

void EscreveTexto( int (*func)(char*) );
int Texto( char*Texto );
int (*p)(char*); /* Cria ponteiro para a função*/
int Retorno = func("Este texto foi passado para a função!"); 

Tipos compatíveis significa que o parametro da função EscreveTexto(), a função Texto(), a variavel p e os parametros passados na função precisam ser compatíveis, isso é, se um for int (char*) todos precisam ser, se for int (char*, int) todos precisam ser assim, etc.

Dos que deram uma série de erros, como ficou o código?

[joubet]

Vamos lá. Se eu fizer:

void EscreveTexto( int (*func)(char,int, char) );

int Texto( char argtxt, int num, char arqtxt2 );

int (*p)(char,int, char);

Dá os erros:

C:\Meus documentos\funcarg.c In function `EscreveTexto':

27 C:\Meus documentos\funcarg.c [Warning] passing arg 1 of pointer to function makes integer from pointer without a cast

27 C:\Meus documentos\funcarg.c [Warning] passing arg 3 of pointer to function makes integer from pointer without a cast

Se eu fizer:

void EscreveTexto( int (*func)(char,int*, char) );

int Texto( char argtxt, int* num, char arqtxt2 );

int (*p)(char,int*, char);

Dá os erros:

C:\Meus documentos\funcarg.c In function `EscreveTexto':

27 C:\Meus documentos\funcarg.c [Warning] passing arg 1 of pointer to function makes integer from pointer without a cast

27 C:\Meus documentos\funcarg.c [Warning] passing arg 2 of pointer to function makes pointer from integer without a cast

27 C:\Meus documentos\funcarg.c [Warning] passing arg 3 of pointer to function makes integer from pointer without a cast

Pelo que entendi de sua resposta, compatibilidade nada tem haver com uso diferenciados de tipos de variáveis como parâmetros como argumento da função, e sim se os tipos declaradas, são compatíveis entre a função que funciona como argumento e a outra função que recebe. Deduzi corretamente ?

A dificuldade que estou percebendo, com base nos exemplos acima, é quando definir ou não as variáveis como ponteiro.

Existe alguma regra geral ? pergunto isso, porque a coisa está meio na base da tentativa e erro.

Obrigado.

[EduardoS]

A dedução esta correta, no casos acima faltou passar os parâmetros do tipo correto, no primeiro resolveria se você chamasse assim:

int i = func(12, 34, 45);//Não ha nenhum ponteiro aqui, nem na declaração da função.

[joubet]

Desculpe, vou abrir este post com o código do programa atualizado, pois os testes acima, foram feitos com esta nova versão. Por isso sua resposta reclama de parâmetros(usar parâmetros certos) , Com o novo código, repetirei a argumentação acima, você poderá entender melhor minha dúvida.

#include <stdio.h>
#include <stdlib.h>
void EscreveTexto( int (*func)(char*,int, char*) );
int Texto( char* argtxt, int num, char* arqtxt2 );
int main ()

{

   int (*p)(char*,int, char*); /* Cria ponteiro para a função e define seu
   parametro como tipo char*/
    
   p = Texto; /* Atribui a função texto ao ponteiro p*/

   EscreveTexto( p ); 
   /* Passa ponteiro para a função como referencia*/
   system ("pause");
   return 0;

}


void EscreveTexto( int (*func)(char*, int, char*) )

{
     
func("texto1", 3, "texto2");   
   /* Executa função que foi passada como referencia */
   
   return;
}

int Texto( char* argtxt, int num, char* argtxt2 )
{
   printf("%s %d %s\n", argtxt,num,argtxt2 );
   return (0);    
}

Vamos lá. Se eu fizer:

void EscreveTexto( int (*func)(char,int, char) );

int Texto( char argtxt, int num, char arqtxt2 );

int (*p)(char,int, char);

Dá os erros:

C:\Meus documentos\funcarg.c In function `EscreveTexto':   
27 C:\Meus documentos\funcarg.c [Warning] passing arg 1 of pointer to function makes integer from pointer without a cast
27 C:\Meus documentos\funcarg.c [Warning] passing arg 3 of pointer to function makes integer from pointer without a cast

Se eu fizer:

void EscreveTexto( int (*func)(char,int*, char) );
int Texto( char argtxt, int* num, char arqtxt2 );
int (*p)(char,int*, char);

Dá os erros:

C:\Meus documentos\funcarg.c In function `EscreveTexto':

27 C:\Meus documentos\funcarg.c [Warning] passing arg 1 of pointer to function makes integer from pointer without a cast

27 C:\Meus documentos\funcarg.c [Warning] passing arg 2 of pointer to function makes pointer from integer without a cast

27 C:\Meus documentos\funcarg.c [Warning] passing arg 3 of pointer to function makes integer from pointer without a cast

Pelo que entendi de sua resposta, compatibilidade nada tem haver com uso diferenciados de tipos de variáveis como parâmetros como argumento da função, e sim se os tipos declaradas, são compatíveis entre a função que funciona como argumento e a outra função que recebe. Deduzi corretamente ?

A dificuldade que estou percebendo, com base nos exemplos acima, é quando definir ou não as variáveis como ponteiro.

Afinal parâmetros tipo char e int estão na mespa posição corespondendo aos argumentos passado.

Existe alguma regra geral ? pergunto isso, porque a coisa está meio na base da tentativa e erro.

Obrigado.

[EduardoS]

Sim deduziu.

Sobre sua dúvida sobre ponteiros, não sei como explicar...

Ponteiros são usados para apontar arrays, strings, parâmetros de retorno, estruturas, etc.

[joubet]

Posso deduzir então que não há uma regra objetiva quanto ao uso de ponteiro como parâmetro de funções como ponteiro para funções ? exceto, que a fariável que vai passar a função para outra função tende ser ponteiro ?

Um outro ponto que me chamou a atenção nesse programa, é a função

void EscreveTexto( int (*func)(char*, int, char*) )

{
     
func("texto1", 3, "texto2");   
   /* Executa função que foi passada como referencia */
   
   return;
}

se eu fizer a chamada da função fora dela, exemplo:

int main()

{
 int (*p)(char*,int, char*); /* Cria ponteiro para a função e define seu
   parametro como tipo char*/
 func("Texto1", 3, "Texto2");

return(0);
}

acusará erro. Por que isso ? eu apreendi, que posso chamar funções das seguintes formas:

main ()
{
       func();
var=func();
      func(a,;
var=func(a,;
 func(&a,&;
var=func(&a,&;

}

E sempre deu certo. Por isso, não entendo qual o probema.

Obrigado

[EduardoS]

Isso acontece porque func é um parâmetro da função EscreveTexto (do tipo ponteiro para função) e o compilador não sabe o que é func fora dessa função.

[joubet]

Estou tentando definir uma forma geral para expressar a passagem de ponteiros para função. Gostaria de saber, se a seguinte formula representa o que estamos discutindo:

Tipo_retorno(*func_arg)(*tipo_var_param1,............. tipo_var_paramN)

Fiz uma nova versão do programa, mas todas as minhas tentativas de fazer com que ele funcione com valores inteiros, me devolve erro de conversão de tipo. Veja o código. Já fiz várias mudanças na declaração de parâmetros mas dá sempre o mesmo tipo de erro. Até a função que retorna void, já tentei mudar o tipo de retorno para int, mas o erro de conversão de tipo perssiste.

#include <stdio.h>
#include <stdlib.h>
void Escrevenum( int (*func)(int*,int*, int*) );
int Textonum( int* num1, int* num2, int* num3 );
int main ()

{

   int (*p)(int*,int*,int*); /* Cria ponteiro para a função e define seu
   parametro como tipo char*/
   p = Textonum; /* Atribui a função texto ao ponteiro p*/
   Escrevenum( p ); 
   /* Passa ponteiro para a função como referencia*/
   system ("pause");
   return 0;

}


void Escrvenum( int (*func)(int*, int*, int*) )

{
     func(1, 2, 3); 
   
   /* Executa função que foi passada como referencia */
   
   return;
}

int Texto( int num1, int* num2, int* num3 )
{
   printf("%d %d %d\n",num1,num2,num3 );
   return (0);    
} 

Obrigado.

[EduardoS]

Tente:

#include <stdio.h>
#include <stdlib.h>
void Escrevenum(int (*func)(int, int, int) );
int Textonum(int num1, int num2, int num3 );
int main ()

{

   int (*p)(int, int, int); /* Cria ponteiro para a função e define seu
   parametro como tipo char*/
   p = Textonum; /* Atribui a função texto ao ponteiro p*/
   Escrevenum( p ); 
   /* Passa ponteiro para a função como referencia*/
   system ("pause");
   return 0;

}


void Escrvenum( int (*func)(int, int, int) )

{
     func(1, 2, 3); 
   
   /* Executa função que foi passada como referencia */
   
   return;
}

int Texto(int num1, int num2, int num3 )
{
   printf("%d %d %d\n", num1, num2, num3);
   return (0);    
}

[joubet]

Rodei a nova versão, já tinha tentado algo parecido, e tive as seguintes mensagens de erro:

[Linker error] undefined reference to `Textonum(int, int, int)'
[Linker error] undefined reference to `Escrevenum(int (*)(int, int, int))'
ld returned 1 exit status

O que que está ocorrendo ? parece que ele não consegue linkar o programa e não consegue retornar algo. Acho que isso passa por aquele papo de definir os ponteiros

Você achou “abobrinha’ aquela de tentar uma forma geral de declaração para ponteiro de funções

Obrigado,

[EduardoS]

Distração minha:

#include <stdio.h>
#include <stdlib.h>
void Escrevenum(int (*func)(int, int, int) );
int Textonum(int num1, int num2, int num3 );
int main ()

{

   int (*p)(int, int, int); /* Cria ponteiro para a função e define seu
   parametro como tipo char*/
   p = Textonum; /* Atribui a função texto ao ponteiro p*/
   Escrevenum( p ); 
   /* Passa ponteiro para a função como referencia*/
   system ("pause");
   return 0;

}
void Escrevenum( int (*func)(int, int, int) )

{
     func(1, 2, 3); 
   
   /* Executa função que foi passada como referencia */
   
   return;
}

int Textonum(int num1, int num2, int num3 )
{
   printf("%d %d %d\n", num1, num2, num3);
   return (0);    
}

[joubet]

:palmas:

OK, funcionou,

Fiz as seguintes experiências com o programa acima:

1) Declarei como ponteiro, os três parâmetros, resultado:

Erro de conversão de tipo

2) Declarei como ponteiro, o primeiro parâmetro, resultado:

Erro de conversão de tipo

Pergunto: Os ponteiros na declaração de parâmetro, só são necessários no tipo char ? sendo dispensáveis nos tipos int, float e doble ?

Obrigado,

[EduardoS]

Não é só char, tambem pode ser int, mas ai precisa passar o endereço de uma variavel, na hora de chamar:

int i;
func(&u, &i, &i);

[joubet]

Fiz:

void Escrevenum( int (*func)(int*, int*, int*) )

{
     int a=1,b=2,c=3;
     func(&a, &b, &c); 
       
   return

E deu certo. Devo deduzir, que esse raciocínio, é válido para todos os tipos numéricos ?

Se a resposta for sim, é correto, que ambas formas abaixo estejam cetras ?

tipo_de_retorno (*nome_do_ponteiro)(declaração_de_parâmetros); ou

tipo_de_retorno (*nome_do_ponteiro)(*declaração_de_parâmetros);

Sendo a segunda forma para parâmetros numérico ?

Obrigado