c++ - 在成员函数上使用外部类的好的设计是什么？

Question

我有以下设计问题，正在寻找最优雅、甚至更重要、最有效的解决方案，因为这个问题来自性能是一个问题的环境。 简单地说，我有一个类“Function_processor”，它对实函数进行一些计算(例如计算一个实函数的根)，我有另一个类“A”，它具有不同的此类函数，需要使用 Function_processor 对它们执行计算.

Function_processor 应该尽可能通用(例如，不要为各种不同的对象提供接口(interface))，而只是坚持自己的任务(为任何函数进行计算)。

#include "function_processor.h"

class A {
    double a;
public:
    A(double a) : a(a) {}
    double function1(double x) {
        return a*x;
    }
    double function2(double x){
        return a*x*x;
    }

    double calculate_sth() {
        Function_processor function_processor(3*a+1, 7);
        return function_processor.do_sth(&function1);
    }
};

class Function_processor {
    double p1, p2;

public:
    Function_processor(double parameter1, double parameter2);

    double do_sth(double (*function)(double));
    double do_sth_else(double (*function)(double));
};

很明显，我不能像下面的示例那样传递成员函数 A::function1/2(我知道，但这大致是我认为可读的代码)。 我也不能使 function1/2 静态，因为它们使用非静态成员 a。 我确信我可以使用 std::bind 或模板之类的东西(即使我对这些东西几乎没有任何经验)但是我最关心的是我将获得的性能。

什么是解决我的问题的最佳(漂亮的代码和快速的性能)解决方案？

感谢您的帮助!

Answer 1

无论是从纯 OO 的角度还是从功能或过程的 POV 角度来看，这都不是真正的最佳方法。首先，您的 A 类实际上只不过是一个必须实例化的命名空间。就个人而言，我只是将它的函数作为自由 float 的 C 风格函数放置 - 也许在某个 namespace 中，以便您获得某种分类。

以下是您在纯 OO 中的做法:

class Function
{
    virtual double Execute(double value);
};
class Function1 : public Function
{
    virtual double Execute(double value) { ... }
};

class FunctionProcessor
{
    void Process(Function & f)
    {
         ...
    }
}

这样，您可以实例化 Function1 和 FunctionProcessor 并将 Function1 对象发送到 Process 方法。您可以从 Function 派生任何东西并将其传递给 Process。

一种类似但更通用的方法是使用模板:

template <class T>
class FunctionProcessor
{
    void Process()
    {
        T & function;
        ...
    }
}

您可以将任何东西作为 T 传递，但在这种情况下，T 成为编译时依赖项，因此您必须在代码中传递它。此处不允许使用动态内容!

这是另一种模板化机制，这次使用简单的函数而不是类:

template <class T>
void Process(T & function)
{
    ...
    double v1 = function(x1);
    double v2 = function(x2);
    ...
}

你可以这样调用它:

double function1(double val)
{
    return blah;
}

struct function2
{
    double operator()(double val) { return blah; }
};

// somewhere else
FunctionProcessor(function1);
FunctionProcessor(function2());

您可以将此方法用于任何可以使用正确签名调用的东西；简单函数、类中的静态方法、仿函数(如上面的 struct function2)、std::mem_fun 对象、新奇的 c++11 lambdas，...如果你使用仿函数，你可以在构造函数中给它们传递参数，就像任何对象一样。

我可能会做最后一个；它是最快的，如果你知道你在编译时调用什么，并且在阅读客户端代码时最简单。如果由于某种原因它必须非常松散地耦合，我会选择基于第一类的方法。我个人认为这种情况很少见，尤其是在你描述问题的时候。

如果您仍想使用您的class A，请将所有不需要成员访问权限的函数设为静态。否则，请查看 std::mem_fun。我仍然不鼓励这种方法。