0

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

我读到的可以解决这个问题的方法是函数指针和虚函数。看起来我可以按照以下方式做一些事情 

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

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

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

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类甚至存在的情况下从我的程序中调用过滤器函数？

或者，如果我完全错了，Filter当我的目标是 1 时，我该如何调用我的函数：让用户定义他们想要的任何过滤器。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
4

2 回答 2

3

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

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

// 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);
    ...
}

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

于 2013-01-22T17:30:22.673 回答
1

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

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

};

class MyWorker : public WorkerBase<MyWorker>
{
public:
   void DoActualWork() {...}
};

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

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

于 2013-01-22T17:28:07.517 回答