如何使用函数指针或虚函数来允许其他程序员定义函数的实现？

How to use function pointers or virtual functions to allow another programmer to define a function's implementation?

本文关键字：函数 程序员 定义 其他 实现 许其他 指针 何使用      更新时间：2023-10-16

我正在编写一个程序，该程序执行一组基本操作，但允许用户填写调用的特定函数（他们在编译之前选择这些函数）。例如，我的程序可能会调用函数filter(input,&output)但用户可以编写自己的过滤器。

我读到的可能解决这个问题的方法就是函数指针和虚函数。看起来我可以做一些类似的事情 

int (*pt2Filter)(float,&float) = NULL;
int IIRFilter(float input, float &output);
pt2Filter=&IIRFilter;

对于函数指针。但这并不能让我跟踪过滤器中的内部状态。

或者，我可以创建一个具有虚拟filter函数的类myClass，然后用户将创建一个继承自myClass并覆盖filter函数的IIR类。

class myClass
{
    virtual void Filter(float input, float &output);
    ...
};
class IIR : public myClass
{
    float stateVariable;
    virtual void Filter(float input, float &output);
}
void IIR::Filter(float input, float &output)
{ //IIR filter done here }

我想我的问题是如何在不知道IIR类存在的情况下从我的程序中调用过滤器函数？

或者，如果我完全错误，当我的目标是 1：让用户定义他们想要的任何过滤器时，我该如何调用我的 Filter 函数。 2：不允许用户更改我的源代码

更新 这可能没有我最初想象的那么困难。我创建了一个头文件，用户将在其中说出他们希望 Filter 类使用以下行调用哪个函数 

//User types this into "FunctionImplementations.h"
#include "IIR.h"
typedef IIR FilterImplementation;
//then I just type
#include "FunctionImplementations.h"
FilterImplementation.filter(); //Implements IIR classes filter function

有几种方法可以实现这种多态性。

主要问题是需要编译时多态行为还是运行时多态行为。在第一种情况下，解决方案通常是定义一个函数（或类）模板来执行您的通用工作，并使用您的泛型代码要调用的可调用对象的类型对其进行参数化，以执行作业的自定义部分：

// This is how you would define your generic procedure
template<typename F> void do_something(F f, ...) 
{ 
    ...
    f(...); 
    ... 
}
// This is how you would use it...
void my_func(...) { ... };
do_something(&my_func, ...); // with a function pointer
do_something([] (...) { ... }, ...); // with a lambda
struct my_functor { operator void () (...) { ... } };
do_something(my_functor(), ...); // with a functor

如果定义自定义行为的对象类型仅在运行时确定，则有两种可能性：要么使用 std::function<> 封装回调，要么使用虚函数方法。我个人更喜欢前者，因为它不会仅仅为了实现动态多态性而强迫您创建继承层次结构。

以下是使用 std::function<> 对象的方式： 

void my_func1(int, int) { ... }
void my_func2(int, int) { ... }
std::function<void(int, int)> fxn = &my_func1;
fxn(2, 3);
...
fxn = &my_func2;
fxn(3, 4);
...
fxn = [] (int x, int y) { ... };
fxn(4, 5)

您可以利用它来定义泛型过程：

void do_something(std::function<void(int, int)> f, ...)
{
    ...
    f(3, 4);
    ...
}

此时，您可以使用可以分配给std::function的任何内容（即具有兼容签名的任何可调用对象）调用do_something()。

如果需要在编译时执行此操作，可以考虑使用模板而不是继承。举个例子：

template<typename Derived> // Derived is having DoActualWork
class WorkerBase
{
public:
   DoWork()
   {
       ((Derived*)this)->DoActualWork();
   }
};
class MyWorker : public WorkerBase<MyWorker>
{
public:
   void DoActualWork() {...}
};

在这里，MyWorker继承类模板WorkerBase将自身作为类型参数传递给模板。从 this 到 Derive 的转换是必需的，并且将起作用，因为此对象实际上是派生类。

请注意，这是使用类的编译时多态性技术之一。通过模板，您可能以其他方式拥有此类功能。 std::map可以与std::greater一起使用！

相关文章：