使用 std::function 包装一个带有可选参数的函数（可能使用 boost::optional），并在另一个 class 中用作模板

Question

在我最近的项目中，我想定义一个 class X，它在其构造函数中有一个输入函数，即 std::function<double(const A&, const B&)>。在实际应用中，class B的参数是可选的（有时不会有这个参数）。所以我试图在我的函数中使用 boost::optional 作为第二个参数。所有 class A 和 B 都将作为模板显示在我的 class X 中。实现我想要的这种行为的最佳方法是什么？

我试过：

class X 的代码:

template <typename Function, typename A, typename B, typename... Args>
class X{
X(Function _f, A _a, boost::optional<B> _b){
 f_{_f};
 a_{_a};
if (_b){b_{_b};}
}
...
private: 
Function f_;
A a_;
boost::optional<B> b_;

public:
void call_function(Args... args){
  f_(args..., a_, boost::option<B> b_);
}
};

函数Function f的定义和实例化X的代码：

double f_example(const A_actual& a, boost::optional<B_actual> b, const OTHER& other){
...
if (b)...
}
... (declare and define instances of A_actual and B_actual and OTHER)...


X<std::function<double(const A_actual&, boost::option<B_actual>, const OTHER&)>, A_actual, boost::option<B_actual>> x(...);

这段代码是否正确，是否能实现我想要的效果？

Answer 1

错字修正后，应该是

#include <functional>
#include <optional>


template <typename Function, typename A, typename B, typename... Args>
class X
{
public:
    X(Function f, A a, std::optional<B> b) :
      f_{f},
      a_{a},
      b_{b}
    {
    }

    void call_function(Args... args){
        f_(a_, b_, args...);
    }
    //...
private: 
    Function f_;
    A a_;
    std::optional<B> b_;
};

和

double f_example(const A_actual& , std::optional<B_actual> , const OTHER& ){
// ...
    return 0.0;
}

void foo(const A_actual& some_a,
         const std::optional<B_actual>& some_b,
         const OTHER& some_other)
{
    X<std::function<double(const A_actual&, std::optional<B_actual>, const OTHER&)>,
      A_actual,
      B_actual,
      const OTHER&> x(f_example, some_a, some_b);
    x.call_function(some_other);
}

Demo

使用 std::function 包装一个带有可选参数的函数（可能使用 boost::optional），并在另一个 class 中用作模板

Use std::function to wrap a function with optional arguments (using maybe boost::optional), and serve as a template in another class

c++

std-function

boost-optional