C++ 如何使函数返回指向函数的指针？（C+；+；）

我试图创建一个函数，它接受一个字符，然后根据该字符是什么返回一个指向函数的指针。我只是不知道如何使函数返回指向函数的指针。

这是显示函数指针返回的代码。首先需要定义“函数签名”以返回：

int returnsOne() {
     return 1;
}

typedef int(*fp)();

fp returnsFPtoReturnsOne() {
    &returnsOne;
}

在您的具体情况下：

fp getFunctionFor(char code) {
    switch (code) {
        case 'a': return &functionA;
        case 'b': return &functionB;
    }
    return NULL;
}

---

为函数签名创建typedef：

typedef void (* FuncSig)(int param);

然后将函数声明为返回FuncSig:

FuncSig GetFunction();

我在这里假设C（没有对象）：：

#包括
使用名称空间std；
int f1（）{
返回1；
}
int f2（）{
返回2；
}
typedef int（*fptr）（）；
fptr f（字符c）{
如果（c=='1'）{
返回f1；
}
否则{
返回f2；
}
}
int main（）{
字符c='1'；
fptr fp=f（c）；
cout最简单的方法是键入指向所需函数类型的指针，然后使用它

typedef void (*fnptr_t)(int, int);
fptr_t myfunc(char *) { ....

< >我更喜欢返回对象并调用操作器（）。这样，函数就可以返回一个接口，所有的类都可以继承这个。也就是说，如果你使用C++而不是C.<
然后，您可以使用参数化因子方法根据输入返回对象。
类似的内容

#include <iostream>

typedef char (*fn_ptr_t)(char);

char a_fn(char c)
{
  return c + 1;
}

char b_fn(char c)
{
  return c + 2;
}

fn_ptr_t
return_function(char c)
{
  fn_ptr_t result = 0;

  switch (c)
 {
    case 'a':
      result = a_fn;
      break;
    case 'b':
      result = b_fn;
      break;
 }

 return result;
}

int
main()
{
  fn_ptr_t fn = return_function('a');

  std::cout << "a(l) = " << (fn)('l') << std::endl;

  return 0;
}

#包括
类型定义字符（*fn_ptr_t）（字符）；
字符a_fn（字符c）
{
返回c+1；
}
字符b_fn（字符c）
{
返回c+2；
}
fn_ptr_t
返回函数（字符c）
{
fn_ptr_t result=0；
开关（c）
{
案例“a”：
结果=a_fn；
打破
案例“b”：
结果=b_fn；
打破
}
返回结果；
}
int
main（）
{
fn_ptr_t fn=返回函数（'a'）；
标准：：cout
不，说真的，请使用typedef:）
查看此网站-

帮助您将英语转换为C声明并返回

很酷的东西

此链接解码erikallen回答中的示例。
以下是如何在不使用typedef的情况下执行此操作：

int c(){ return 0; }

int (* foo (void))(){  //compiles
return c;
}

返回函数的语法：

return_type_of_returning_function (*function_name_which_returns_function)(actual_function_parameters) (returning_function_parameters)

例如：
考虑需要返回的函数如下：

void* (iNeedToBeReturend)(double iNeedToBeReturend_par)
{
}

现在，iNeedToBeReturend函数可以作为

void* (*iAmGoingToReturn(int iAmGoingToReturn_par))(double)
{
   return iNeedToBeReturend;
}

在经历了3年的专业编程生涯后，我对学习这个概念感到非常难过

等待解引用函数指针的奖励


返回函数指针的函数示例如下
在C++11中，可以使用尾随返回类型来简化语法，例如，假设函数：

int c(int d) { return d * 2; }

这可以从函数返回（需要一个double来显示）：

使用尾随返回类型，这将更易于阅读：

auto foo2(double e) -> int(*)(int)
{
    e;
    return c;
}

假设
intf（char）
和
ret\u f
返回
&f

C++98/C++03兼容方式：


丑陋的方式：

int (*ret_f()) (char) { return &f; }


使用typedef：

typedef int (sig)(char);

sig* ret_f() { return &f; }

或：



自C++11以来，我们还有：


尾随返回类型：

auto ret_f() -> int(*)(char) { return &f; }

或：


typedef
与
一起使用
：

using sig = int(char);

sig* ret_f() { return &f; }

或：



C++14增加了：


自动
扣除：

auto ret_f() { return &f; }


返回函数的签名是否总是相同的？下面是一个函数的签名，它接受一个函数指针并返回一个：我想知道为什么会这样。我们是否应该先尊重函数指针，即
cout@qed:No。您可以取消引用它，但不这样做完全可以。通常的函数已经存在ter仍然是内部的。@Axalo程序按原样编译。
return\u f
不接受任何参数，而是返回一个带有字符的函数。您能否详细说明“使用typedef”？提供一个快捷方式
typedef int（*ifc）（char）；
并将其用作函数中的返回类型：
ifc return\u f（）；
a“开发人员参考答案”，直截了当！非常感谢。非常有帮助！
int (*ret_f()) (char) { return &f; }

typedef int (sig)(char);

sig* ret_f() { return &f; }

typedef int (*sig_ptr)(char);

sig_ptr ret_f() { return &f; }

auto ret_f() -> int(*)(char) { return &f; }

auto ret_f() -> decltype(&f) { return &f; }

using sig = int(char);

sig* ret_f() { return &f; }

using sig_ptr = int (*)(char);

sig_ptr ret_f() { return &f; }

auto ret_f() { return &f; }