C++ 从类或独立函数指向函数的函数指针

我有两个具有相同输入和输出类型的函数

uint32_t doWork(uint32_t time);
uint32_t MyClass::DoWork(uint32_t time);

现在我想把这个函数注入到另一个类中，或者使用其中一个函数

所以我想我可以使用一个函数点，但这不起作用，因为函数指针需要使用类类型

有没有办法将两个函数存储在同一个函数指针类型中并将其传递给构造函数

类中的函数不是静态的

---

感谢您的帮助

>我用C++编译器做了一些实验。 以下是我得到的，似乎正在做这项工作：

#include <stdio.h>

typedef unsigned int uint32_t;

typedef uint32_t (doWorkPtr) (uint32_t time);

uint32_t doWork(uint32_t time) {
  return time*2;
}

class MyClass {
  public:
  int times;
  int DoWork(uint32_t time) { return time*times; }
};

struct Adapter {
  MyClass* a;
  doWorkPtr* ptr;
  int operator() (uint32_t time) {
    if(a)
      return a->DoWork(time);
    else
      return ptr(time);
  }
};

int main(int argc, char** argv) {
  Adapter* pointers[2];

  MyClass klass;
  klass.times = 3;
  Adapter adapter;
  adapter.a = &klass;
  adapter.ptr = 0;

  Adapter adapter2;
  adapter2.a = 0;
  adapter2.ptr = &doWork;

  pointers[0] = &adapter;
  pointers[1] = &adapter2;

  printf("result1 %i\n", (*pointers[0])(1));
  printf("result2 %i\n", (*pointers[1])(1));

  return 0;
}

#包括
typedef unsigned int uint32\u t；
类型定义uint32_t（工作时间）（uint32_t时间）；
uint32工作时间（uint32时间）{
返回时间*2；
}
类MyClass{
公众：
整数倍；
int DoWork（uint32_t time）{返回时间*次；}
};
结构适配器{
MyClass*a；
doWorkPtr*ptr；
int运算符（）（uint32\u t时间）{
如果（a）
返回a->DoWork（时间）；
其他的
返回ptr（时间）；
}
};
int main（int argc，字符**argv）{
适配器*指针[2]；
MyClass klass；
klass.times=3；
适配器；
adapter.a=&klass；
adapter.ptr=0；
适配器适配器2；
适配器2.a=0；
适配器2.ptr=&doWork；
指针[0]=&适配器；
指针[1]=&适配器2；
printf（“result1%i\n”，（*指针[0]）（1））；
printf（“result2%i\n”，（*指针[1]）（1））；
返回0；
}

在使用此函数时，您的类将存储“适配器”指针，而不是普通函数指针

---

希望有帮助

>我用C++编译器做了一些实验。 以下是我得到的，似乎正在做这项工作：

#include <stdio.h>

typedef unsigned int uint32_t;

typedef uint32_t (doWorkPtr) (uint32_t time);

uint32_t doWork(uint32_t time) {
  return time*2;
}

class MyClass {
  public:
  int times;
  int DoWork(uint32_t time) { return time*times; }
};

struct Adapter {
  MyClass* a;
  doWorkPtr* ptr;
  int operator() (uint32_t time) {
    if(a)
      return a->DoWork(time);
    else
      return ptr(time);
  }
};

int main(int argc, char** argv) {
  Adapter* pointers[2];

  MyClass klass;
  klass.times = 3;
  Adapter adapter;
  adapter.a = &klass;
  adapter.ptr = 0;

  Adapter adapter2;
  adapter2.a = 0;
  adapter2.ptr = &doWork;

  pointers[0] = &adapter;
  pointers[1] = &adapter2;

  printf("result1 %i\n", (*pointers[0])(1));
  printf("result2 %i\n", (*pointers[1])(1));

  return 0;
}

#包括
typedef unsigned int uint32\u t；
类型定义uint32_t（工作时间）（uint32_t时间）；
uint32工作时间（uint32时间）{
返回时间*2；
}
类MyClass{
公众：
整数倍；
int DoWork（uint32_t time）{返回时间*次；}
};
结构适配器{
MyClass*a；
doWorkPtr*ptr；
int运算符（）（uint32\u t时间）{
如果（a）
返回a->DoWork（时间）；
其他的
返回ptr（时间）；
}
};
int main（int argc，字符**argv）{
适配器*指针[2]；
MyClass klass；
klass.times=3；
适配器；
adapter.a=&klass；
adapter.ptr=0；
适配器适配器2；
适配器2.a=0；
适配器2.ptr=&doWork；
指针[0]=&适配器；
指针[1]=&适配器2；
printf（“result1%i\n”，（*指针[0]）（1））；
printf（“result2%i\n”，（*指针[1]）（1））；
返回0；
}

在使用此函数时，您的类将存储“适配器”指针，而不是普通函数指针

---

希望有帮助

如果使用类成员，它如何知道要对哪个对象执行操作？相关/重复：额外级别的间接寻址会造成伤害吗？指向独立函数的指针与指向类成员方法的指针大不相同。因此，不能将它们存储在相同的指针类型中，更不用说以相同的方式调用它们了。考虑使用代替原始指针。@ ReMyLeBeaAh，我看到我从C背景来，并且编程C++ 10 +年前。这是一个新的发展。如果您将此添加为一个答案，我可以接受。如果您使用类成员，它如何知道要对哪个对象执行操作？相关/重复：额外级别的间接操作会造成伤害吗？指向独立函数的指针与指向类成员方法的指针大不相同。因此，不能将它们存储在相同的指针类型中，更不用说以相同的方式调用它们了。考虑使用代替原始指针。@ ReMyLeBeaAh，我看到我从C背景来，并且编程C++ 10 +年前。这是一个新的发展。如果你加上这个作为回答，我可以接受。