Question

我在下面的代码运行正常，并给出了预期的结果。 我还有一个额外的查询，如何在main函数中声明一个包含函数A（funcA）地址的指针？

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


int funcB (void)
{
 printf("\n Now you are in function B \n ");

 printf ("\n this function is for returning code value no matter what\n");

 return -10;
}

int (*funcA(int x,int y)) (void)
{
 printf( " I am in function A \n ");
   static int sum;
   sum=x+y;
 printf ( "\n Sum is %d ",sum);
 return &funcB;
 }

int main ()

{

int (*fpb)(void);

int x;

fpb=funcA(10,15);

x=(*fpb)();   // Calling function B through fpb pointer

printf("\n Value stored in x for code is %d \n",x);

}

结果：

I am in function A

Sum is 25
Now you are in function B

this function is for returning code value no matter what

Value stored in x for code is -10

Answer 1

语法足够grokky，最好使用typedef。我不是在假设C ++ 11。 ()围绕*NameOfType：

typedef int (*funcBTypePointer) (void);

int main ()
{
    funcBTypePointer fpb;

    ...
}

我看到funcA将返回funcB的地址。以下是如何做到这一点：

funcBTypePointer funcA(int x,int y)
{
 printf( " I am in function A \n ");
 static int sum;
 sum=x+y;
 printf ( "\n Sum is %d ",sum);
 return funcB;
}

如果你引用一个没有参数列表的函数，你会得到一个指向该函数的指针;

有关函数指针的更多信息，请参阅本教程：http://www.learncpp.com/cpp-tutorial/78-function-pointers/

Answer 2

如何在main函数中声明一个包含函数A（funcA）地址的指针？

你可以直接写（和uglily）：

int (*(*fpa)(int,int)) (void) = &funcA;
您可以使用typedef说清楚：

typedef int (*FPB)(void);
typedef FPB (*FPA)(int, int);
FPA fpa = &funcA;
因为您标记了c ++，所以可以使用auto specifier（因为c ++ 11）使其直接且清晰：

auto fpa = &funcA;

Answer 3

要找出指向funcA的指针的类型，请接受funcA的声明：

int (*funcA(int x,int y)) (void)

并将funcA替换为(*fptr)，因此您的声明将变为

int (*(*fptr)(int x, int y))(void);

读作

        fptr                          -- fptr
       *fptr                          -- is a pointer
      (*fptr)(            )           -- to a function with
      (*fptr)(    x,      )           -- parameter x
      (*fptr)(int x,      )           --   is an int
      (*fptr)(int x,     y)           -- parameter y
      (*fptr)(int x, int y)           --   is an int
     *(*fptr)(int x, int y)           -- returning a pointer
    (*(*fptr)(int x, int y))(    )    -- to a function with
    (*(*fptr)(int x, int y))(void)    -- no parameters
int (*(*fptr)(int x, int y))(void);   -- returning int

您将其指定为

fptr = funcA;

并将其命名为

int x = (*(*fptr)(a,b))();

请注意，虽然我们中的一些人¹发现这种声明完全透明，但大多数C程序员都不会对这个级别的声明语法有所了解，而更喜欢隐藏typedef背后的大部分复杂性：

typedef int fb(void);
typedef fb *fa(int x, int y);

fa *fptr = funcA;

但是，该声明并未真正告诉您如何在表达式中使用 fptr，而

int (*(*fptr)(int x, int y))(void);

非常明确：

int x = (*(*fptr)(a,b))();

<小时/> ^{1。我会高兴地承认我是这方面的异常者;我曾经编写了一些代码，它几乎完成了上面fptr调用的功能（也就是说，通过单个表达式中的指针调用多个函数），并认为它非常清晰。我的同事很快就提醒我，我很奇怪并且坚持要把它们分成不同的陈述}

Answer 4

声明“指向函数的指针”的第一条规则是“使用typedef”。当你在两周后回来的时候，你会感激不尽，并试着弄清楚到底是怎么回事。

typedef void (*pfuncB_t)();  // (void) is a C-compatability hack.  Use () in C++.

所以funcA的声明变得更容易阅读：

pfuncB_t funcA(int x, int y);

...并且声明指向funcA的指针的类型也很容易。

typedef pfuncB_t (*pfuncA_t)(int, int);

你可以像以下一样使用它：

pfuncA_t globalA = &funcA;   // You don't need the address-of, but it is legal.

Answer 5

如何声明一个可以指向funcA的指针？

除非你非常勇敢（并且我懒得勇敢），否则使用typedef指向FuncB类型的指针：

typedef int (*FunctionReturningInt)(void);

现在，funcA是一个返回FunctionReturningInt的函数：

extern FunctionReturningInt funcA(int x, int y);

创建指向该指针的指针：

FunctionReturningInt (*funcA_ptr)(int x, int y) = funcA;

Answer 6

使用一些typedef s

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

int funcB(void) {
    printf("Now you are in function B\n");
    printf("this function is for returning code value no matter what\n");
    return -10;
}

int (*funcA(int x,int y)) (void) {
    printf("I am in function A\n");
    static int sum;
    sum = x + y;
    printf("Sum is %d\n", sum);
    return &funcB;
}

// typedefs to make life easier    
typedef int (ta)(void);
typedef ta *(tb)(int, int); // use previous typedef'd ta

int main(void) {
    int x, y;
    ta *fpb;
    tb *fpa;

    fpb = funcA(10, 15);
    fpa = funcA;
    x = fpb();   // Calling function B through fpb pointer
    y = fpa(10, 15)(); // calling function B through pointer to function A

    printf("Value stored in x for code is %d\n", x);
    printf("Value stored in y for code is %d\n", y);

    return 0;
}

Answer 7

还值得一提的是，您也可以使用std::function（c ++ 11）。但是，这不是一个函数指针，而是一个可以保存任何可调用对象的包装器。与简单指针相比，这是一种更重的方法。

如果函数指针对你的情况来说足够了而且你不需要管理很多函数那么我肯定会建议使用函数指针。

（http://en.cppreference.com/w/cpp/utility/functional/function）

#include <cstdio>
#include <cstdlib>
#include <functional>


int funcB()
{
  printf("\n Now you are in function B \n ");
  printf("\n this function is for returning code value no matter what\n");
  return -10;
}

std::function<int(void)> funcA(int x, int y)
{
  printf(" I am in function A \n ");
  static int sum;
  sum = x + y;
  printf("\n Sum is %d ", sum);
  return funcB;
}

int main()
{
  std::function<std::function<int(void)>(int, int)> func_a = funcA;
  std::function<int(void)> func_b = func_a(10, 15);
  int x = func_b();

  printf("\n Value stored in x for code is %d \n", x);

  return 0;
}

如何声明指向返回函数指针的函数的指针

7 个答案: