如何使函数返回指向函数的指针? (C + +)

我尝试创建一个接受字符的函数，然后根据字符的类型返回一个指向函数的指针。我只是不确定如何让一个函数返回一个指向函数的指针。

77803 次浏览
小开

这是返回函数指针的密码。您需要定义“函数签名”以便首先返回:

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 在这里(没有对象) :) :

// Type of function which takes a char and returns an int:
typedef int (*Func)(char a);


// An example of the function you're trying to return and which does something
// with char:
int exampleFunc(char a)
{
return (int)(a + 42);
}


// The function returning the pointer to a function:
Func *returnAfunc(void)
{
return exampleFunc;
}
小开 
typedef void (*voidFn)();


void foo()
{
}


voidFn goo(char c)
{
if (c == 'f') {
return foo;
}
else {
//..
}
// ..
}
小开
最佳答案 
#include <iostream>
using namespace std;


int f1() {
return 1;
}


int f2() {
return 2;
}


typedef int (*fptr)();




fptr f( char c ) {
if ( c == '1' ) {
return f1;
}
else {
return f2;
}
}


int main() {
char c = '1';
fptr fp = f( c );
cout << fp() << endl;
}
小开

最简单的方法是类型定义所需的指针到函数类型，然后使用该类型

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;
}
小开 
int f(char) {
return 0;
}


int (*return_f())(char) {
return f;
}

不，说真的，用 typedef:)

小开

看看这个网站-http://cdecl.org

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

酷毙了！

这个链接解码了 Erikallen 答案中的例子。 Int (* return _ f ())(char)

小开

以下是不使用 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 + + 面试问题

返回函数指针的函数的例子是 在 c + + 动态库中使用 dlopen

小开

在 C + + 11中，您可以使用尾随返回类型来简化语法，例如，假设一个函数:

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

这可以从一个函数返回(需要一个双精度函数来显示) :

int (*foo(double e))(int)
{
e;
return c;
}

使用尾随返回类型，可以更容易地阅读:

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

假设返回 &f的 int f(char)和 ret_f。

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

  • 丑陋的方式:

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

  • 使用 typedef:

    typedef int (sig)(char);


sig* ret_f() { return &f; }

    或:

    typedef int (*sig_ptr)(char);


sig_ptr ret_f() { return &f; }

从 C + + 11开始，我们还有:

  • 以下连结载有 decltype:

    decltype(&f) ret_f() { return &f; }

  • 尾随报税表类别:

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

    或:

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

  • typedef与 using:

    using sig = int(char);


sig* ret_f() { return &f; }

    或:

    using sig_ptr = int (*)(char);


sig_ptr ret_f() { return &f; }

C + + 14补充称:

  • 扣除:

    auto ret_f() { return &f; }

提交答案