Comment imprimer des noms en cascade de pointeurs de fonctions?

Question

Je travaillais des exemples de pointeurs de fonctions et j'ai développé 4 fonctions simples et les ai assignées à un tableau de pointeurs de fonction, puis j'ai couru le code et travaillé pour les 4 fonctions, mais j'ai pensé imprimer les noms des fonctions.

J'ai appris environ __func__ et il imprime seulement le nom de la fonction courante, ainsi est-il de toute façon assigner __func__ au pointeur de fonction ou à une autre méthode pour imprimer les noms des fonctions?

C'est l'exemple que je travaille en ce moment:

#include <stdio.h> 
#include <stdlib.h> 
#include <inttypes.h> 


int add(int x, int y); 
int sub(int x, int y); 
int mul(int x, int y); 
int divide(int x, int y); 


int main() { 
    int m = 6; 
    int n = 10; 
    int res,i; 


    int (*fun[4])(int,int)={add,sub,mul,divide}; 

    for (i=0;i<4;i++) 
    { 
     printf("result of %s operation\n",__func__=fun[i]); 
    } 
} 

int add(int x, int y) { 
int result = x + y; 
return result; 
} 

int sub(int x, int y) { 
int result = x - y; 
return result; 
} 

int mul(int x, int y) { 
int result = x * y; 
return result; 
} 

int divide(int x, int y) { 
int result = x/y; 
return result; 
} 

Comme vous pouvez le voir, je suis en train d'affecter le __func__ aux fonctions pointeur mais bien sûr, cela ne fonctionne pas.

Answer 1

La __func__ constante dans toutes les fonctions ne sont accessibles que dans l'exécution. Ce qui signifie que si vous voulez utiliser celui-là, vous devez l'attraper en appelant la fonction. Comme ceci:

typedef int calc_func_t (int x, int y, const char** func); 

int add(int x, int y, const char** func); 
... 

calc_func_t* fun[4] = {add,sub,mul,divide}; 

for (i=0;i<4;i++) 
{ 
    const char* func; 
    int result = fun[i](1,1,&func); 
    printf("result of %s operation %d\n", func, result); 
} 

... 

int add(int x, int y, const char** func) 
{ 
    int result = x + y; 
    *func = __func__; 
    return result; 
} 

... 

Si vous souhaitez savoir ce que les fonctions sont nommées à la compilation, puis plus tard sur l'utilisation de cette information, le plus facile et le meilleur moyen serait de créer une table de consultation:

typedef struct 
{ 
    calc_func_t* func; 
    const char* name; 
} calc_func_info_t; 

const calc_func_info_t func_info [] = 
{ 
    {add, "add"}, 
    {sub, "sub"}, 
    ... 
}; 

Answer 2

Fondamentalement, il n'y a aucun moyen.

// A function declaration 
void MyFunction(void); 

// a pointer to the function 
void (*fnPointer)(void) = MyFunction; 

// No way to retrieve function name "MyFunction" from fnPointer 

Ofcourse, si vous avez un ensemble connu de fonctions possibles qui pourraient être affectées au pointeur, vous pouvez les comparer explicitement.

Vous pouvez également modifier le pointeur de fonction stocké à associer au nom de la fonction. Pourrait être quelque chose de similaire à ce qui suit:

struct FunctionPointerContainer 
{ 
    void (*fnPointer)(void); 
    char* fnName; 
}; 

#define MakeFunctionPointer(fn) FunctionPointerContainer { fn, #fn } 

// later 
struct FunctionPointerContainer myPointer = MakeFunctionPointer(MyFunction); 
myPointer.fnPointer(); // call 
myPointer.fnName; // the function name 

Answer 3

Le code compilé ne contient pas les noms de fonctions et de symols par défaut. Vous pouvez utiliser des macros pour créer des chaînes constantes contenant les noms de fonctions à inclure dans le binaire compilé:

#include <stdio.h> 

// function call type 
typedef void fn_call(); 

// record describing one function 
typedef struct fn_record { 

    const char *name; // function's name as a constant string 
    fn_call *call; // function call 

} fn_record; 

// the functions to be called and named 
void fna() { printf("called fna\n"); } 
void fnb() { printf("called fnb\n"); } 
void fnc() { printf("called fnc\n"); } 

// macro, that generates record for each function, it creates 
// string like { "fna", fna } to save You typing 
#define FN_RECORD(f) { #f, f } 

// now define array of functions records 
fn_record fns[3] = { 
    FN_RECORD(fna), 
    FN_RECORD(fnb), 
    FN_RECORD(fnc) 
}; 

// ... which becomes: 
// fn_record fns[3] = { 
//  { "fna", fna }, 
//  { "fnb", fnb }, 
//  { "fnc", fnc } 
// }; 


int main(void) { 

    int i; 

    // ... use it whatever You like 
    for (i = 0; i < 3; i++) { 

     printf("%s\n", fns[i].name); 
     fns[i].call(); 
    } 

    return 0; 
} 

Answer 4

je travaillais des fonctions pointeurs exemples

donc, si je comprends, votre exemple est fait à des fins éducatives, n'êtes-vous pas? Dans ce cas, je le ferais aussi simplement que possible pour ne pas confondre les étudiants qui utilisent votre exemple pour apprendre comment fonctionnent les pointeurs.

je l'ai appris __func__ et il imprime uniquement le nom de la fonction actuelle

Malgré d'autres réponses montrent des solutions très agréable et intelligent comment avoir le nom de la fonction en dehors de celui-ci, du point de vue simplicité je toujours utiliser le __func__ comme il fonctionne normalement, dans la fonction appelée:

#include <stdio.h> 
#define print_info(format, ...) \ 
    printf("Function '%s' is called with parameters: "format"\n", \ 
    __func__, __VA_ARGS__) 

int add(int x, int y); 
int sub(int x, int y); 
int mul(int x, int y); 
int divide(int x, int y); 

int main() { 
    int m = 6, n = 10, i;  
    int (*fun[4])(int,int) = { add, sub, mul, divide }; 

    for (i = 0; i < 4; ++i) 
     printf("-- result is: %d\n", fun[i](n, m)); 

    return 0; 
} 

int add(int x, int y) { 
    print_info("%d, %d", x, y); 
    return x + y; 
} 

int sub(int x, int y) { 
    print_info("%d, %d", x, y); 
    return x - y; 
} 

int mul(int x, int y) { 
    print_info("%d, %d", x, y); 
    return x * y; 
} 

int divide(int x, int y) { 
    print_info("%d, %d", x, y); 
    return x/y; 
}