获取C/C+中函数内部的函数地址+；？_C_Pointers

获取C/C+中函数内部的函数地址+；？

c pointers

获取C/C+中函数内部的函数地址+；？,c,pointers,C,Pointers,我试图返回我调用的函数的地址，类似于： void * myfunctionname(some parameters) { //some codes //more codes. return &myfunctionname; } 如何用正确的类型替换void*，以获得正确的签名？问题是要有正确的返回类型，它是“递归的”，因为它包含自身正如我所知，拥有“递归”类型的唯一方法是使用结构或联合，所以或汇编（两种方式相同）：问题是要有正确的返回类型，它是“递归的”，因为它包含

我试图返回我调用的函数的地址，类似于：

void * myfunctionname(some parameters) {
  //some codes
  //more codes.
  return &myfunctionname;
}

如何用正确的类型替换

void*

，以获得正确的签名？

问题是要有正确的返回类型，它是“递归的”，因为它包含自身

正如我所知，拥有“递归”类型的唯一方法是使用结构或联合，所以

或

汇编（两种方式相同）：

问题是要有正确的返回类型，它是“递归的”，因为它包含自身

正如我所知，拥有“递归”类型的唯一方法是使用结构或联合，所以

或

汇编（两种方式相同）：

如果用指向函数的指针将“某些参数”括在结构中，可能更容易阅读，如中所示

typedef struct some_parameters
{
    int a;
    int b;
    struct some_parameters*
        (*my_function_name)(struct some_parameters*);
}   Some_parm;

通过这种方式，您可以将函数编写为

Some_parm* my_function_name(Some_parm* parm)
{
    // some codes
    // more codes
    // yet more code
    printf("F(): a = %d, b = %d\n", parm->a, parm->b);
    parm->a += 1;
    parm->b += 1;
    parm->my_function_name = my_function_name;
    return parm;
};

然后像这样编写代码

    Some_parm sp;
    sp.a = 10;
    sp.b = 20;
    sp.my_function_name = NULL;
    my_function_name(&sp); // call function directly
    printf("main(): a = %d, b = %d\n", sp.a, sp.b);
    sp.my_function_name(&sp); // call function from inside sp
    printf("main(): a = %d, b = %d\n", sp.a, sp.b);
    sp.my_function_name(&sp);
    printf("main(): a = %d, b = %d\n", sp.a, sp.b);
    my_function_name(&sp);
    printf("main(): a = %d, b = %d\n", sp.a, sp.b);

pF_fii my_other_function(pF_fii one, int a, int b)
{    
    // some codes
    // more codes
    // yet more code
    printf("[function] a = %d, b = %d\n", a, b);
    return (pF_fii)&my_other_function;
};

但是您可以编写

typedef

：

typedef void* (*pF_fii)
    ( void* (*)(void*, int, int), int, int );

用参数替换2

int

。然后像这样声明函数

    Some_parm sp;
    sp.a = 10;
    sp.b = 20;
    sp.my_function_name = NULL;
    my_function_name(&sp); // call function directly
    printf("main(): a = %d, b = %d\n", sp.a, sp.b);
    sp.my_function_name(&sp); // call function from inside sp
    printf("main(): a = %d, b = %d\n", sp.a, sp.b);
    sp.my_function_name(&sp);
    printf("main(): a = %d, b = %d\n", sp.a, sp.b);
    my_function_name(&sp);
    printf("main(): a = %d, b = %d\n", sp.a, sp.b);

pF_fii my_other_function(pF_fii one, int a, int b)
{    
    // some codes
    // more codes
    // yet more code
    printf("[function] a = %d, b = %d\n", a, b);
    return (pF_fii)&my_other_function;
};

这是输出

F（）：a=10，b=20
main（）：a=11，b=21
F（）：a=11，b=21
main（）：a=12，b=22
F（）：a=12，b=22
main（）：a=13，b=23
F（）：a=13，b=23
main（）：a=14，b=24
仅使用函数
[功能]a=2，b=3
[功能]a=4，b=5

这个节目的

#包括
类型定义无效*（*pF_fii）
（void*（*）（void*，int，int），int，int）；
pF_fii my_other_函数（pF_fii one，int a，int b）
{    
//一些代码
//更多代码
//还有更多代码
printf（“[函数]a=%d，b=%d\n”，a，b）；
返回（pF_fii）&my_other_函数；
};
typedef结构的一些参数
{
INTA；
int b；
构造一些参数*
（*我的函数名）（构造一些参数*）；
}一些人；
一些参数*我的函数名（一些参数*参数）
{
//一些代码
//更多代码
//还有更多代码
printf（“F（）：a=%d，b=%d\n”，参数->a，参数->b）；
parm->a+=1；
parm->b+=1；
参数->我的函数名称=我的函数名称；
返回parm；
};
内部主（空）
{
一些帕尔姆sp；
sp.a=10；
sp.b=20；
sp.my_function_name=NULL；
my_function_name（&sp）；//直接调用函数
printf（“main（）：a=%d，b=%d\n”，sp.a，sp.b）；
sp.my_function_name（&sp）；//从sp内部调用函数
printf（“main（）：a=%d，b=%d\n”，sp.a，sp.b）；
sp.my\u函数名称（&sp）；
printf（“main（）：a=%d，b=%d\n”，sp.a，sp.b）；
我的职能部门名称（&sp）；
printf（“main（）：a=%d，b=%d\n”，sp.a，sp.b）；
//使用独立函数
printf（“\n仅使用函数\n\n”）；
pF_fii另一个f=NULL；
另一个函数=我的另一个函数（另一个函数，2，3）；
另一个函数=我的另一个函数（另一个函数，4，5）；
返回0；
};```