C++ 返回指向Self的函数指针？

下面的代码没有编译..但是有没有办法让函数指针返回另一个与自身等价的函数指针

typedef FunctionPtr (*FunctionPtr)(int, int);

FunctionPtr Second(int, int);
FunctionPtr First(int, int)
{
    // do something
    return Second;
}

FunctionPtr Second(int, int)
{
    // do something
    return First;
}

int main()
{
    FunctionPtr a = First(1, 2);
    FunctionPtr b = a(2, 3);
    FunctionPtr c = b(4, 5);
    c(5, 6);
}

---

简短回答：不，你不能直接这么做。您可以通过使用void指针来接近它，但这是不标准的，因为void指针不能保证足够大以容纳函数指针。有关详细信息，请参阅

最接近标准兼容的方法是为函数指针定义包装器类型：

 struct Wrapper;
 typedef Wrapper (*FunctionPtr)(int, int);
 struct Wrapper {
    Wrapper(FunctionPtr ptr): wrapped(ptr) { }
    operator FunctionPtr() { return wrapped; }
    FunctionPtr wrapped;
 };

现在你可以写：

Wrapper Second(int, int);
Wrapper First(int, int) {
    // do something
    return Second;
}

Wrapper Second(int, int) {
    // do something
    return First;
}

int main() {
    FunctionPtr a = First(1, 2);
    FunctionPtr b = a(2, 3);
    FunctionPtr c = b(4, 5);
    c(5, 6);
}

---

这是不可能的，因为类型检查。它需要编译器在类型检查中解决固定点问题，而目前编译器无法做到这一点

您可以做的最接近的事情是通过继承抽象出返回类型：

template<class T>
class Function { public: virtual void Map(T t)=0; };

template<class T, class K>
class FunctionPtr : public Function<T> {
public:
  FunctionPtr(K (*fptr)(T)) : fptr(fptr) { }
  void Map(T t) { fptr(t); }
private:
  K (*fptr)(T);
};

Function<int> *my_function(int i)
{
   return new FunctionPtr<int,Function<int>*>(&my_function);
}

模板
类函数{public:virtualvoidmap（T）=0；}；
模板
类函数ptr：公共函数{
公众：
函数ptr（K（*fptr）（T））：fptr（fptr）{}
void映射（T）{fptr（T）；}
私人：
K（*fptr）（T）；
};
函数*my_函数（int i）
{
返回新函数ptr（&my_函数）；
}

这是我15分钟内最接近的一次…：

#include <stdio.h>

struct container
{
    typedef container (*Ptr)(int, int);
    const Ptr _ptr;
    explicit container(Ptr ptr) : _ptr(ptr) { }
    operator Ptr() const { return _ptr; }
};

struct container narcissus(int a, int b)
{
  printf("Narcissus: %i %i.\n", a, b);

  return container(narcissus);
}

int main(void)
{
  narcissus(3, 4)(5, 6)(7, 8);
  return 0;
}

#包括
结构容器
{
类型定义容器（*Ptr）（内部，内部）；
常数Ptr_Ptr；
显式容器（Ptr-Ptr）：\u-Ptr（Ptr）{}
运算符Ptr（）常量{return\u Ptr；}
};
结构容器narcissus（内部a、内部b）
{
printf（“水仙：%i%i.\n”，a，b）；
返回容器（水仙）；
}
内部主（空）
{
水仙（3,4）（5,6）（7,8）；
返回0；
}

---

现在让这个n个参数的通用类作为一个练习留给读者：（

这里有几个聪明的C++解决方案，但是我一直看到的纯C解决方案只是使用一个小的铸造：

typedef void (*func)(void);

func myfunc(int, int) { return (func)myfunc); }
// optional
typedef func (*myfunctype)(int, int);

// calling code
myfunctype x = myfunc;
while(x) x = (myfunctype)x(2, 3);

该标准要求转换到另一个函数指针类型并返回的函数指针与原始函数指针相同，从而使此代码完全可靠。

-第2.7节-谷歌是您的朋友。