如何传递std :: function作为函数指针？

Question

我正在尝试编写一个类模板，并在内部使用具有以下接口的C函数（由R环境提供的BFGS优化的实现）：

void vmmin(int n, double *x, double *Fmin, 
           optimfn fn, optimgr gr, ... ,
           void *ex, ... );

其中fn和gr是类型的函数指针

typedef double optimfn(int n, double *par, void *ex);

和

typedef void optimgr(int n, double *par, double *gr, void *ex);

分别。 我的C++类模板如下所示：

template <typename T>
class optim {
 public:
  // ...
  void minimize(T& func, arma::vec &dpar, void *ex) {
    std::function<optimfn> fn = 
      std::bind(&T::fr, func, std::placeholders::_1, 
                std::placeholders::_2, std::placeholders::_3);
    std::function<optimgr> gr = 
      std::bind(&T::grr, func, std::placeholders::_1,
                std::placeholders::_2, std::placeholders::_3,
                std::placeholders::_4);
    // ERROR: cannot convert std::function to function pointer
    vmmin(... , fn, gr, ...);
    // ...
  }  
};

这样它就可以由具有两个指定成员函数的任何类实例化，例如：

class Rosen {
 public:
  // ...
  double fr(int n, double *par, void *ex);
  void grr(int n, double *par, double *gr, void *ex);
 private:
  // ...
};

// main.cc
Rosen func;
optim<Rosen> obj;
obj.minimize(func, dpar, ex);

这可能吗？ 或者，也许有更好的方法可以将两个成员函数分别作为函数指针传递？ （如果目标函数和相应的梯度很简单，则编写两个函数绝对可以。但是，大多数情况下，我遇到的问题要复杂得多，必须将该问题作为一个类来实现）。

Answer 1

我先说：

我不认可以下库的用法

#include<tuple>
#include<type_traits>
#include<utility>

// func_traits
template <typename T>
struct func_traits : public func_traits<decltype(&std::remove_reference_t<T>::operator())> {};

template <typename Callable, typename Ret, typename... Args>
struct func_traits<Ret(Callable::*)(Args...) const> {
    using ptr_type = Ret (*) (Args...);
    using return_type =  Ret;

    template<std::size_t i>
    struct arg
    {
        using type = typename std::tuple_element<i, std::tuple<Args...>>::type;
    };

    template<typename Ret2>
    using cast_return_type = Ret2 (*) (Args...);
};

template<typename Ret, typename... Args>
struct func_traits<Ret (&) (Args...)> : public func_traits<Ret (*) (Args...)> {};

template <typename Ret, typename... Args>
struct func_traits<Ret (*) (Args...)>
{
    using ptr_type = Ret (*) (Args...);
    using return_type =  Ret;

    template<std::size_t i>
    struct arg
    {
        using type = typename std::tuple_element<i, std::tuple<Args...>>::type;
    };

    template<typename Ret2>
    using cast_return_type = Ret2 (*) (Args...);
};



// constexpr counter
template <int N>
struct flag
{
    friend constexpr int adl_flag(flag<N>);
    constexpr operator int() { return N; }
};

template <int N>
struct write
{
    friend constexpr int adl_flag(flag<N>) { return N; }
    static constexpr int value = N;
};

template <int N, int = adl_flag(flag<N>{})>
constexpr int read(int, flag<N>, int R = read(0, flag<N + 1>{}))
{
    return R;
}

template <int N>
constexpr int read(float, flag<N>)
{
    return N;
}

template <int N = 0>
constexpr int counter(int R = write<read(0, flag<N>{})>::value)
{
    return R;
}


// fnptr
template<int nonce = counter()>
class fnptr
{
    //these are to make sure fnptr is never constructed
    //technically the first one should be enough, but compilers are not entirely standard conformant
    explicit fnptr() = delete;
    fnptr(const fnptr&) {}
    ~fnptr() = delete;

    template<typename Callable, typename Ret, typename... Args>
    static auto cast(Callable&& c, Ret(*fp)(Args...)) -> decltype(fp)
    {
        using callable_type = std::remove_reference_t<Callable>;
        static callable_type clb{std::forward<Callable>(c)};
        static bool full = false;
        if(full)
        {
            clb.~callable_type();
            new (&clb) decltype(clb){std::forward<Callable>(c)};
        }
        else
            full = true;
        return [](Args... args) noexcept(noexcept(clb(std::forward<Args>(args)...))) -> Ret
        {
            return Ret(clb(std::forward<Args>(args)...));
        };
    }

public:
    template<typename Signature, typename Callable>
    static Signature* cast(Callable&& c)
    {
        return cast(std::forward<Callable>(c), static_cast<Signature*>(nullptr));
    }

    template<typename Signature, typename Ret, typename... Args>
    static auto cast(Ret (*fp)(Args...))
    {
        static decltype(fp) fnptr;
        fnptr = fp;
        using return_type = typename func_traits<Signature*>::return_type;
        return [](Args... args) noexcept(noexcept(fp(std::forward<Args>(args)...)) -> return_type
        {
            return return_type(fnptr(std::forward<Args>(args)...));
        };
    }

    template<typename Callable>
    static auto get(Callable&& c)
    {
        return cast(std::forward<Callable>(c), typename func_traits<Callable>::ptr_type{nullptr});
    }

    template<typename Ret, typename... Args>
    static auto get(Ret (*fp)(Args...))
    {
        return fp;
    }
};

并用作

#include<functional>
#include<iostream>

using optimfn = double (int, double*, void*);
using optimgr = void (int, double*, double*, void*);

void test(optimfn* fn, optimgr* gr)
{
    double d;
    fn(42, &d, &d);
    gr(42, &d, &d, &d);
}

int main()
{
    std::function<optimfn> fn = [](int, double*, void*){
        std::cout << "I'm fn" << std::endl;
        return 0.;
    };
    std::function<optimgr> gr = [](int, double*, double*, void*){
        std::cout << "I'm gr" << std::endl;
    };

    test(fnptr<>::get(fn), fnptr<>::get(gr));
}

现场例子

func_traits

只是一个辅助特征类型，它将以易于访问的形式获取任何可调用的类型

constexpr counter

这是发生的事情的一半邪恶。 有关详细信息，请访问是否形成了有状态的元编程病？

fnptr

代码的实际内容。 它接受具有适当签名的所有可调用对象，并在每次调用时隐式声明一个匿名C函数，并将可调用对象强制转换为C函数。

它具有时髦的语法fnptr<>::get和fnptr<>::cast<Ret(Args...)> 。 这是故意的 。

get将声明具有与可调用对象相同签名的匿名C函数。

cast适用于任何兼容的可调用类型，即，如果返回类型和参数是隐式可转换的，则可以对其进行强制转换。

注意事项

fnptr 在调用它的代码的每个点上隐式声明一个匿名C函数。 它实际上不是一个与std::function相同的变量。

如果再次在代码中调用相同的fnptr ，则所有地狱之fnptr都会丢失。

std::vector<int(*)()> v;
for(int i = 0; i < 10; i++)
    v.push_back(fnptr<>::get([i]{return i;}));  // This will implode

你被警告了。

Answer 2

基本上，您需要一个具有正确签名的自由函数，将void *参数与“用户数据”一起使用（否则将无法使用），从某种程度上提取指向std::function的指针/引用，并用其他参数调用它。 一个简单的例子来说明我的意思：

void call_it(int value, void * user) {
  std::function<void(int)> * f = static_cast<std::function<void(int)>*>(user);
  (*f)(value);
}
// pass it as callback:
registerCallback(call_it, static_cast<void *>(&my_std_function));

当然，您需要确保指针保持有效！

使用下面的代码，您无需为每个可能的签名编写此类call_it函数。 上面的示例显示为：

registerCallback(trampoline<1, Single::Extract<void,int>, void, int, void *>,
                 Single::wrap(my_std_function));

您的情况将是：

// obj and ex passed as parameters
std::function<double(int, double *)> fn =
  [ex, &obj] (int a, double * b) { return obj.fr(a, b, ex); };
std::function<void(int, double *, double *)> gr =
  [ex, &obj] (int a, double * b, double * c) { obj.grr(a, b, c, ex); };
void * fns = Multi<2>::wrap(fn, gr);
vmmin(... ,
      trampoline<2, Multi<2>::Extract<0, double, int, double *>, double, int, double *, void *>,
      trampoline<3, Multi<2>::Extract<1, void, int, double *, double *>, void, int, double *, double *, void *>,
      ..., fns, ...); // fns passed as ex
Multi<2>::free_wrap_result(fns);

---

我对ideone的“ scratch area”进行分叉和测试。 现在，要救援的模板：

template<
    std::size_t N, ///> index of parameter with the user data
    typename Extractor,
    typename R,
    typename... Args>
R trampoline (Args... args) {
  auto all = std::make_tuple(std::ref(args)...);
  auto arguments = tuple_remove<N>(all);
  return std::apply(Extractor{}.get_function(std::get<N>(all)),
                    arguments);
}

std::apply是C ++ 17的东西，尽管您应该可以在此站点上轻松找到与C ++ 11兼容的版本。 N指定包含“用户数据”的参数（即指向实际功能的指针）的（从零开始的）索引。 Extractor是一种具有静态get_function成员函数的类型，给定一个void *为std::apply返回“可调用”值。 该用例的灵感来自于您的实际问题：如果只有一个带有“用户数据”的指针， 该指针将传递给两个 （或多个）不同的回调，那么您需要一种方法来“提取”这些不同的函数。不同的回调。

单个功能的“提取器”：

struct Single {
  template<typename R, typename... Args>
  struct Extract {
    std::function<R(Args...)> & get_function(void * ptr) {
        return *(static_cast<std::function<R(Args...)>*>(ptr));
    }
  };
  template<typename R, typename... Args>
  static void * wrap(std::function<R(Args...)> & fn) {
    return &fn;
  }
};

其中一项具有多种功能：

template<std::size_t Num>
struct Multi {
  template<std::size_t I, typename R, typename... Args>
  struct Extract {
    std::function<R(Args...)> & get_function(void * ptr) {
      auto arr = static_cast<std::array<void *, Num> *>(ptr);
      return *(static_cast<std::function<R(Args...)>*>((*arr)[I]));
    }
  };
  template<typename... Fns>
  static void * wrap(Fns &... fns) {
    static_assert(sizeof...(fns) == Num, "Don't lie!");
    std::array<void *, Num> arr = { static_cast<void *>(&fns)... };
    return static_cast<void*>(new std::array<void *, Num>(std::move(arr)));
  }
  static void free_wrap_result(void * ptr) {
    delete (static_cast<std::array<void *, Num>*>(ptr));
  }
};

请注意，这里wrap做分配，因此必须在free_wrap_result进行相应的取消分配。 这仍然是非常普遍的……应该转换为RAII。

---

tuple_remove仍然需要编写：

template<
    std::size_t N,
    typename... Args,
    std::size_t... Is>
auto tuple_remove_impl(
    std::tuple<Args...> const & t,
    std::index_sequence<Is...>) {
  return std::tuple_cat(if_t<N == Is, Ignore, Use<Is>>::from(t)...);
}
template<
    std::size_t N,
    typename... Args>
auto tuple_remove (std::tuple<Args...> const & t) {
  return tuple_remove_impl<N>(t, std::index_sequence_for<Args...>{});
}

if_t （请参阅下文）只是我的std:: conditional简写，需要实现Use和Ignore ：

struct Ignore {
  template<typename Tuple>
  static std::tuple<> from(Tuple) {
    return {};
  }
};
template<std::size_t N>
struct Use {
  template<typename Tuple>
  static auto from(Tuple t) {
    return std:: make_tuple(std::get<N>(t));
  }
};

tuple_remove利用std::tuple_cat接受空的std::tuple<>参数，由于无法get某些内容，因此基本上会忽略它们。

---

std::conditional简写：

template<bool Condition,
         typename Then,
         typename Else>
using if_t = typename std::conditional<
    Condition, Then, Else>::type;

Answer 3

另一种解决方案是让optim类使用两个（可能是纯的）虚拟函数发挥作用，然后继承以定义实现它们的新类Rosen 。 这看起来像

class optim {
    public:
        // ...

        virtual double fn(int n, double *par, void *ex) = 0;
        virtual void gr(int n, double *par, double *gr, void *ex) = 0;

        void minimize(arma::vec &dpar, void *ex) {
            vmmin(... , &fn, &gr, ...);
            // ...
        }
};

class Rosen : public optim {
    public:
        // ...
        double fn(int n, double *par, void *ex);
        void gr(int n, double *par, double *gr, void *ex);

    private:
        // ...
};

// main.cc    
Rosen obj;
obj.minimize(dpar, ex);