C++ 如何将std::function作为函数指针传递?
我试图编写一个类模板,它在内部使用一个C++ 如何将std::function作为函数指针传递?,c++,r,function-pointers,std-function,C++,R,Function Pointers,Std Function,我试图编写一个类模板,它在内部使用一个C函数(BFGS优化的实现,由R环境提供),接口如下: 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); 及 分别。我的C++类模板如下所示: tem
C
函数(BFGS优化的实现,由R
环境提供),接口如下:
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);
及
分别。我的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, ...);
// ...
}
};
模板
类optim{
公众:
// ...
无效最小化(T&func,arma::vec&dpar,无效*ex){
std::函数fn=
std::bind(&T::fr,func,std::占位符::\u 1,
std::占位符::_2,std::占位符::_3);
std::函数gr=
标准::绑定(&T::grr,func,标准::占位符::\u 1,
标准::占位符::_2,标准::占位符::_3,
标准::占位符::4);
//错误:无法将std::函数转换为函数指针
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);
classrosen{
公众:
// ...
双倍fr(整数n,双倍*面值,无效*汇率);
无效grr(整数n,双倍*par,双倍*gr,无效*ex);
私人:
// ...
};
//main.cc
Rosen func;
optimobj;
目标最小化(func,dpar,ex);
这可能吗?或者有更好的方法来实现这一点——将两个成员函数分别作为函数指针传递?(如果目标函数和相应的梯度很简单,写两个函数是绝对可以的。但是,大多数时候,我遇到的问题要复杂得多,我必须将问题作为一个类来实现)。基本上,你需要一个具有正确签名的自由函数,使用带有“用户数据”的
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));
一个用于多个功能:
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));
}
};
如果t
(见下文)只是我对std::conditional
的简写,则需要实现使用和忽略:
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));
}
};
另一种解决方案是让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);
让我先说:
我不赞成使用以下库
#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;
}
};
您已收到警告。您不能在需要函数指针的地方使用std::function。std::function
键入擦除其类型并允许更多该函数指针,您可以从另一个方向执行。你能让你的方法静态的直接传递它吗?或者你需要Rosen的实例吗?我是否应该发布一个非常粗糙的方法,它做了非常糟糕的事情,但从技术上来说,它肯定地回答了这个问题?@Jarod42刚刚尝试了一个简单的例子,使该方法成为静态的,它就工作了。谢谢也许我稍后会尝试一个更复杂的方法。void*ex
是传递回调用方函数的不透明cookie,还是用于其他用途?你需要一个闭包来完成这件事,而这正是我所期望的……你测试过这个来看看会发生什么吗?你说得对,这是不可能的。抱歉,Jay,这也行不通。主要问题是编译器“无法将成员函数fn的double(optim::*)(int,double*,void*)转换为double()(int,double,void*)”(对于gr应该是相同的)。错误消息还说“ISO C++禁止接受不合格或括号的非静态成员函数的地址”。换句话说,它只有在成员函数是静态的情况下才起作用。哇,这太糟糕了:请注意,它(希望)会在C++17中崩溃(那时他们会设法禁止constexpr计数器)。
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));
}
};
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...>{});
}
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));
}
};
template<bool Condition,
typename Then,
typename Else>
using if_t = typename std::conditional<
Condition, Then, Else>::type;
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);
#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));
}
std::vector<int(*)()> v;
for(int i = 0; i < 10; i++)
v.push_back(fnptr<>::get([i]{return i;})); // This will implode