Question

我正在尝试使用boost :: function，我是C ++的新手并且正在做一个课程。

我有什么：

class OptionPricer {
    [constructor etc..]
    double CallPrice(const double S);
    double PutPrice(const double S);
    double CallPrice(const double S, const double putPrice);
    double PutPrice(const double S, const double callPrice);
    vector<double> OptionPricer::Mesher(const double start, const double end, const double h, boost::function<double (const double)> funct);
};

我想使用boosts函数指针，所以我不必复制Mesher函数，只需传递* Price函数。

我尝试做什么：

boost::function<double (double)> functCP = &OptionPricer::CallPrice;

但我明白了：

ClCompile：OptionPricer.cpp Main.cpp c：\ c ++ \ 9.a.1 \ 9.a.1 \ main.cpp（34）：错误C2440：＆＃39;初始化＆＃39; ：无法转换为超载功能＆＃39;至＆＃39;的boost ::功能＆＃39; 同 [ 签名=双（双） ] 没有构造函数可以采用源类型，或者构造函数重载解析是不明确的

我也尝试过没有addressof运算符，但我的经验太少，无法完全理解这类问题。如果有人可以建议它会很棒。

感谢您的评论，我之前尝试过const double。

鉴于我现在尝试过这个建议，这个建议起作用，因为另一个问题出现了。

在Mike Seymour的建议下，我现在得到了这个：

    // Calculate meshes 
    double start = 0, end = 20, h = 0.5;
    boost::function<double (const double)> functCP = boost::bind(&OptionPricer::CallPrice, &pricer1, _1);
    boost::function<double (const double)> functPP = boost::bind(&OptionPricer::PutPrice, &pricer1, _1);
    cout << "Calculate meshes:" << endl;
    cout << "Mesh1 Call: " << pricer1.Mesher(start, end, h, functCP) << " Mesh1 Put: " << pricer1.Mesher(start, end, h, functPP) << endl;
    cout << "Mesh2 Call: " << pricer2.Mesher(start, end, h, functCP) << " Mesh2 Put: " << pricer2.Mesher(start, end, h, functPP) << endl;
    cout << "Mesh3 Call: " << pricer3.Mesher(start, end, h, functCP) << " Mesh3 Put: " << pricer3.Mesher(start, end, h, functPP) << endl;

为什么我不想使用实例是因为我需要将它绑定到所有3个pricer实例，它们包含用于构建网格的数据。它们的实例值不同，我想我可能需要以某种方式使绑定更具动态性。

E.g。上面的函数不正确，因为我在pricer2和pricer3实例上只使用了pricer1函数绑定。

我现在要做的是复制pricer2，pricer3等。实际上我想摆脱冗余而不是重复网格，因为它只是在一个范围内迭代，现在我仍然有一些复制但是肯定比在功能方面有一种重复更好。

boost::function<double (const double)> functCP = boost::bind(&OptionPricer::CallPrice, &pricer2, _1);
boost::function<double (const double)> functPP = boost::bind(&OptionPricer::PutPrice, &pricer2, _1);

摆脱冗余，可能不是最技术性的解决方案，但是：

boost::function<double (const double)> bindCPricer(OptionPricer &pricer) {
    return boost::bind(&OptionPricer::CallPrice, &pricer, _1);
}

boost::function<double (const double)> bindPPricer(OptionPricer &pricer) {
    return boost::bind(&OptionPricer::PutPrice, &pricer, _1);
}

cout << "Mesh1 Call: " << pricer1.Mesher(start, end, h, bindCPricer(pricer1)) << " Mesh1 Put: " << pricer1.Mesher(start, end, h, bindPPricer(pricer1)) << endl;
    cout << "Mesh2 Call: " << pricer2.Mesher(start, end, h, bindCPricer(pricer2)) << " Mesh2 Put: " << pricer2.Mesher(start, end, h, bindPPricer(pricer2)) << endl;

非常感谢您的投入！

顺便说一下。我已经编程Java超过10年了，我想知道为什么我之前没有学过C ++，到目前为止它对我来说看起来更强大，提升很棒，模板也比Java Generics更复杂。

Answer 1

function对象需要自己调用，而成员函数需要一个对象。所以你需要将它绑定到一个：

OptionPricer pricer; // The object you want the function to use
boost::function<double (double)> functCP = 
    boost::bind(&OptionPricer::CallPrice, &pricer, _1);

这会将函数绑定到指向pricer的指针，因此调用函数functCP(x)等同于pricer.CallPrice(x)。请注意，如果对象是可复制的，很容易意外地绑定到它的副本，这可能不是你想要的。

或者，在现代C ++中，你可以使用lambda（你也可以使用标准库而不是Boost）：

std::function<double (double)> functCP = 
    [&pricer](double x){return pricer.CallPrice(x);};

我发现它比绑定表达式更具可读性;你的美学可能会有所不同。

成员函数的boost :: function

1 个答案: