C++ 返回指向函数的指针，该函数具有基于参数的不同签名

我已经看过，但想知道如何编写一个函数，返回指向函数的指针，该函数的签名取决于调用函数的参数（如果可能的话）

例如：

如果我有

typedef void (*func1) (int);
typedef void (*func2) (int, int);

我希望有一个函数

get_func

，它根据整型参数的值返回指向一个或另一个的指针，例如：

get_func1（0）

返回

func1

；

---

get_func2（1）

返回

func2

我认为你不能这样做

您可能想做的是返回一个指向函数的指针，该函数将一些

struct

指针作为它的唯一参数，并且在该

struct

中有数量可变的参数

typedef void (*func1) (struct MyStruct*);

然后在

MyStruct

中：

struct MyStruct {
  int param;
  struct MyStruct* next;
};

---

或者类似的。您可以将结构链接在一起，并将它们全部读取为“参数”。

我认为您不能这样做

您可能想做的是返回一个指向函数的指针，该函数将一些

struct

指针作为它的唯一参数，并且在该

struct

中有数量可变的参数

typedef void (*func1) (struct MyStruct*);

然后在

MyStruct

中：

struct MyStruct {
  int param;
  struct MyStruct* next;
};

---

或者类似的。您可以将结构链接在一起，并将所有结构都作为“参数”读取。

我知道我在这里会得到很多否决票，但如果您想要什么，渴望得到什么，知道风险并同意它，您可以降低编译器检查以得到您想要的

下面我向你展示一种获得你想要的东西的方法。我不建议你这么做，但如果你相信这正是你想要的，那就继续吧

#include <iostream>

using namespace std;

typedef void (*func1) (int);
typedef void (*func2) (int, int);

void f1(int)
{
  cout << "f1" << endl;
}

void f2(int, int)
{
  cout << "f2" << endl;
}

void call(int x, void *t)
{
  if ( x ) 
    reinterpret_cast<func1>(t)(0);
  else
    reinterpret_cast<func2>(t)(0, 0);
}

int main()
{
  call(0, reinterpret_cast<void*>(f1));
  call(1, reinterpret_cast<void*>(f2));
}

#包括
使用名称空间std；
typedef void（*func1）（int）；
typedef void（*func2）（int，int）；
无效f1（整数）
{
我知道我会在这里得到很多反对票，但是如果你想要什么，渴望得到什么，知道风险并同意，你可以降低编译器检查以得到你想要的

下面我给你展示了一种获得你想要的东西的方法。我不建议你这么做，但如果你相信这正是你想要的，那就继续吧

#include <iostream>

using namespace std;

typedef void (*func1) (int);
typedef void (*func2) (int, int);

void f1(int)
{
  cout << "f1" << endl;
}

void f2(int, int)
{
  cout << "f2" << endl;
}

void call(int x, void *t)
{
  if ( x ) 
    reinterpret_cast<func1>(t)(0);
  else
    reinterpret_cast<func2>(t)(0, 0);
}

int main()
{
  call(0, reinterpret_cast<void*>(f1));
  call(1, reinterpret_cast<void*>(f2));
}

#包括
使用名称空间std；
typedef void（*func1）（int）；
typedef void（*func2）（int，int）；
无效f1（整数）
{
cout怎么样

#include <stdio.h>

typedef void (*func1) (int);
typedef void (*func2) (int, int);

union func12 {
  void* f0;
  func1 f1;  
  func2 f2;
};

void f1(int) {
  printf( "f1\n" );
}

void f2(int, int) {
  printf( "f2\n" );
}

func12 get_func( int x ) {
  func12 r;
  if( x ) r.f2=f2; else r.f1=f1;
  return r;
}

int main() {
  get_func(0).f1(0);
  get_func(1).f2(0,0);
}

#包括
typedef void（*func1）（int）；
typedef void（*func2）（int，int）；
工会职能12{
void*f0；
功能1 f1；
func2f2；
};
无效f1（整数）{
printf（“f1\n”）；
}
空f2（整数，整数）{
printf（“f2\n”）；
}
func12 get_func（int x）{
功能12R；
如果（x）r.f2=f2；否则r.f1=f1；
返回r；
}
int main（）{
get_func（0）.f1（0）；
get_func（1）.f2（0,0）；
}

怎么样

#include <stdio.h>

typedef void (*func1) (int);
typedef void (*func2) (int, int);

union func12 {
  void* f0;
  func1 f1;  
  func2 f2;
};

void f1(int) {
  printf( "f1\n" );
}

void f2(int, int) {
  printf( "f2\n" );
}

func12 get_func( int x ) {
  func12 r;
  if( x ) r.f2=f2; else r.f1=f1;
  return r;
}

int main() {
  get_func(0).f1(0);
  get_func(1).f2(0,0);
}

#包括
typedef void（*func1）（int）；
typedef void（*func2）（int，int）；
工会职能12{
void*f0；
功能1 f1；
func2f2；
};
无效f1（整数）{
printf（“f1\n”）；
}
空f2（整数，整数）{
printf（“f2\n”）；
}
func12 get_func（int x）{
功能12R；
如果（x）r.f2=f2；否则r.f1=f1；
返回r；
}
int main（）{
get_func（0）.f1（0）；
get_func（1）.f2（0,0）；
}

您可以使用两个不同的
运算符（）返回一个对象
重载。否则为否-这是一种静态类型的语言。调用代码如何使用结果？调用方在尝试调用指向函数时如何知道有多少个参数及其类型？是否查看了
std:：function
？可以返回具有两个不同
运算符（）
重载。否则否-这是一种静态类型的语言。调用代码如何使用结果？调用方在尝试调用指向函数时如何知道有多少个参数及其类型？您是否看过
std:：function
？@Haole:我怀疑这一点，您可能是对的。我必须考虑一下还有一些。但最终可能会像你建议的那样。@Haole:我也怀疑这一点，你可能是对的。我会再考虑一下。但最终可能会像你建议的那样。@Badan:谢谢你的回复-尽管如此，这还是有用的。@Badan:谢谢你的回复-尽管如此，这还是有用的。