I have got a problem with calling a global function, which takes a pointer to a function as a parameter.
Here is the declaration of the global function:
int lmdif ( minpack_func_mn fcn, void *p, int m, int n, double *x,
double *fvec, double ftol)
The "minpack_func_mn" symbol is a typedef for a pointer to a function, defined as:
typedef int (*minpack_func_mn)(void *p, int m, int n, const double *x,
double *fvec, int iflag );
I want to call the "lmdif" function with a pointer to a function which is a member of a class I created, and here is the declaration of this class function:
int LT_Calibrator::fcn(void *p, int m, int n, const double *x,
double *fvec,int iflag)
I am calling a global function like this:
info=lmdif(<_Calibrator::fcn, 0, m, n, x, fvec, ftol)
Unfortunately, I get a compiler error, which says:
"error C2664: 'lmdif' : cannot convert parameter 1 from 'int (__thiscall LT_Calibrator::* )(void *,int,int,const double *,double *,int)' to 'minpack_func_mn'
1> There is no context in which this conversion is possible"
Is there any way to solve that problem?
It looks to me like the lmdif function takes the "void *p" as a user argument that it just passes to the callback (minpack_func_mn fcn).
If that is the case, just make LT_Calibrator::fcn a static function, and pass your object as the "p" parameter. Then you can cast the user-argument (p) to get your object back, if you want.
class LT_Calibrator
{
public:
static int fcn(void *p, int m, int n, const double *x, double *fvec,int iflag)
{
LT_Calibrator* pCalibrator = static_cast<LT_Calibrator*>( p );
}
};
Then call like:
LT_Calibrator someCalibrator;
info=lmdif(<_Calibrator::fcn, &someCalibrator, m, n, x, fvec, ftol);
Essentially there is an implicit argument for a member function (the this pointer) which makes this tricky. Check out this FAQ entry for more information.
You need a non-member or static member function; a member function pointer can't be used in place of your function type because it requires an instance to call it on.
If your function doesn't need access to a LT_Calibrator instance, then you can simply declare it static, or make it free function. Otherwise, it looks like you can use the first argument (void *p) to pass an instance pointer into a "trampoline" function, which can then call a member function. Something along the lines of this:
// member function
int LT_Calibrator::fcn(int m, ...);
// static (or non-member) trampoline
static int fcn_trampoline(void *p, int m, ...)
{
return static_cast<LT_Calibrator*>(p)->fcn(m,...);
}
info = lmdif(&fcn_trampoline, this, m, ...);
Related
void Frame::ExtractORB(int flag, const cv::Mat &im)
{
if(flag==0)
(*mpORBextractorLeft)(im,cv::Mat(),mvKeys,mDescriptors);
else
(*mpORBextractorRight)(im,cv::Mat(),mvKeysRight,mDescriptorsRight);
}
How to use like this format?
(*name)(param1, param2, param3, param4)
this code is belong to orb_slam ....
https://github.com/raulmur/ORB_SLAM2
A declaration of a pointer to a non-member function has the following structure:
return-type (* name)(argument-list)
So in order to declare a pointer functo a function taking a const char* and an intas an argument and returning bool you say
bool (*func)(const char*, int);
Note, that you need the parenthesis around the *func, because otherwise the compiler would interpret it as a declaration of function
bool* func(const char*, int);
returning bool*.
Assume now, that you have a function
bool foo(const char* x, int y) { /* ... */ }
of corresponding type, then you can make your pointer point to this function by
func = &foo;
In order to invoke the function pointed to by func, you dereference the pointer and invoke it with the arguments like this
bool result = (*func)("abc", 3);
This is what you are doing in the example you provided. Calling the function pointed to by mpORBextractorLeft (resp. mpORBextractorRight) with the given arguments.
Some further notes:
Dereferencing of the function pointer may be omitted, so
bool result = func("abc", 3);
should work as well.
When declaring the pointer, it can be initialized immediately:
bool (*func)(const char*, int) = &foo;
A typedef can be used to simplify code if you need to write the type of the pointer multiple times:
typedef bool (*fun_ptr)(const char*, int);
fun_ptr func1 = &foo;
fun_ptr func2 = &bar;
Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 9 years ago.
Improve this question
Why does the following compiles i.e. passing a free function as parameter with the right signature:
inline double free_adapter_f(unsigned n, const double *x, double *grad, void *d) {
return 0.0;
}
nlopt::opt opt(nlopt::LN_NELDERMEAD, X.size());
opt.set_min_objective(free_adapter_f, NULL);
whereas this other doesn't compile i.e. passing the result of boost::bind a class member function with the same signature:
template<class Space, class Solution, class Oracle>
inline double NelderMead<Space, Solution, Oracle>::adapter_f(unsigned n, const double *x, double *grad, void *d) {
return 0.0;
}
nlopt::opt opt(nlopt::LN_NELDERMEAD, X.size());
opt.set_min_objective(boost::bind(&NelderMead::adapter_f, this, ::_1, ::_2, ::_3, ::_4), NULL);
The error message is the following:
nelder_mead.h(98): error: no instance of overloaded function "nlopt::opt::set_min_objective" matches the argument list
argument types are: (boost::_bi::bind_t<double, boost::_mfi::mf4<double, NelderMead<TestSpace, VectorXd, oracle_f>, unsigned int, const double *, double *, void *>, boost::_bi::list5<boost::_bi::value<NelderMead<TestSpace, VectorXd, oracle_f> *>, boost::arg<1>, boost::arg<2>, boost::arg<3>, boost::arg<4>>>, long)
object type is: nlopt::opt
opt.set_min_objective(boost::bind(&NelderMead::adapter_f, this, ::_1, ::_2, ::_3, ::_4), NULL);
UPDATE: the overloaded set_min_objective are:
typedef double (*func)(unsigned n, const double *x, double *grad, void *f_data);
typedef double (*vfunc)(const std::vector<double> &x, std::vector<double> &grad, void *f_data);
void set_min_objective(func f, void *f_data);
void set_min_objective(vfunc vf, void *f_data);
You need to define set_min_objective which accepts boost::function as first parameter:
typedef boost::function<double (unsigned n, const double *x, double *grad, void *f_data)> func_t;
...
void set_min_objective(func_t, void*);
...
another thing - you'd better not to use NULL
Here is a simple example, which demonstrates your problem:
#include <iostream>
#include <boost/bind.hpp>
#include <boost/function.hpp>
namespace g
{
typedef int (*func)(int a, int b, int c);
void bar(func f)
{
std::cout << "g::bar:: called" << (*f)(10, 20, 30) << std::endl;
}
// Disable the over load below and you will get the same error
void bar(boost::function<int(int, int, int)> f)
{
std::cout << "g::bar:: called" << f(10, 20, 30) << std::endl;
}
}
template <typename A, typename B, typename C>
class foo
{
public:
int bar(int a, int b, int c) const
{ return a + b + c; }
void call()
{
g::bar(boost::bind(&foo::bar, this, ::_1, ::_2, ::_3));
}
};
int main(void)
{
foo<int, double, int> f;
f.call();
return 0;
}
Main reason is that boost::function<> is not convertible to a function pointer, so you need to provide an overload which accepts this (as above.)
EDIT: just to clarify things a little further. boost::bind() does not explicitly return a boost::function<>, however, the object it returns can be stored in the correct instantiation of boost::function<>, in the above case, the correct instantiation is boost::function<int(int, int, int)>.
Normally you would only need to resort to storing it in a boost::function if you were interested in propagating it (without a template) or storing it for later use. In this case, as you are passing the result of the bind(), you need to have the correct overload to accept the returned object from boost::bind(), and the easiest way to do this without resorting to templates is to accept a boost::function (as above.)
Normally, I'm pragmatic, so I would resort to this (without knowing what you are wanting to do with f) where possible.
template <typename F>
double set_min_objective(F f, ...)
{
}
Then you are agnostic, of course purists will have other opinions.
NOTE: A nice thing with boost::function<> is that you can store a non-member function pointer in one too (as long as the signature matches.) So in reality you only need a version of your function which accepts the correct boost::function<> and it will work in both cases (member function with boost::bind() and non-member function.)
EDIT2: Okay, given the additional information, you have to resort to the following mechanism, you need to have a non-member function of your class, which will then delegate to the member function, for example:
<>
class NelderMead
{
static double delegate_f(unsigned n, const double *x, double *grad, void *f_data)
{
// I'm assuming here the frame work passed you whatever you gave in f_data
NelderMead* inst = reinterpret_cast<NelderMead*>(f_data);
return inst->adapter_f(n, x, grad);
}
double adapter_f(unsigned n, const double *x, double *grad)
{
}
void set()
{
nlopt::opt opt(nlopt::LN_NELDERMEAD, X.size());
opt.set_min_objective(delegate_f, this); //<-- here pass the instance as the additional data
}
};
This is a typical pattern employed by third-party libraries which are meant to be agnostic to user code.
Both overloads of set_min_objective expect a pointer-to-function as the first parameter, but the object returned by boost::bind is not a pointer-to-function, it's a function object.
boost::bind returns a function object that stores the target function and any bound arguments, it doesn't synthesize a function and return a pointer to it, or magically turn a pointer-to-member-function into a pointer-to-function. That would be magic.
Can you please explain what does the following line means?
typedef int (*Callback)(void * const param,int s)
It means that Callback is a new name for the type : pointer to a function returning an int and taking two parameters of type 'const pointer to void' and 'int'.
Given a function f :
int f(void * const param, int s)
{
/* ... */
}
The Callback can be used to store a pointer to f :
Callback c = &f;
The function f can be later invoked through the pointer without directly referring to its name :
int result = c(NULL, 0);
At the point of the call, the name f does not appear.
It creates a new "alias" or name by which you can refer to pointers to functions that return int and take two parameters: a void* const and an int. You can then create variables of that type, assign to them, invoke the function through them etc as in:
int fn(void * const param,int s) { ... }
Callback p;
p = fn;
int x = p(NULL, 38);
Note that typedefs do not really create new types... every equivalent typedef is resolved to the single real type for the purposes of overload resolution, template instantiation etc..
It declares a function type:
// Set up Callback as a type that represents a function pointer
typedef int (*Callback)(void * const param,int s);
// A function that matches the Callback type
int myFunction(void* const param,int s)
{
// STUFF
return 1;
}
int main()
{
// declare a variable and assign to it.
Callback funcPtr = &myFunction;
}
I have a problem using a very complicated C function in a C++ class (rewriting the C function is not an option). C function:
typedef void (*integrand) (unsigned ndim, const double* x, void* fdata,
unsigned fdim, double* fval);
// This one:
int adapt_integrate(unsigned fdim, integrand f, void* fdata,
unsigned dim, const double* xmin, const double* xmax,
unsigned maxEval, double reqAbsError, double reqRelError,
double* val, double* err);
I need to supply a void function of type integrand myself, and adapt_integrate will calculate the n-dimensional integral. The code in calcTripleIntegral (below) works as a standalone function if func is a standalone function).
I want to pass a (non-static!) class member function as the integrand, as this can be easily overloaded etc...
class myIntegrator
{
public:
double calcTripleIntegral( double x, double Q2, std::tr1::function<integrand> &func ) const
{
//...declare val, err, xMin, xMax and input(x,Q2) ...//
adapt_integrate( 1, func, input,
3, xMin, xMax,
0, 0, 1e-4,
&val, &err);
return val;
}
double integrandF2( unsigned ndim, const double *x, void *, // no matter what's inside
unsigned fdim, double *fval) const; // this qualifies as an integrand if it were not a class member
double getValue( double x, double Q2 ) const
{
std::tr1::function<integrand> func(std::tr1::bind(&myIntegrator::integrandF2, *this);
return calcTripleIntegral(x,Q2,func);
}
}
On GCC 4.4.5 (prerelease), this gives me:
error: variable 'std::tr1::function func' has initializer but incomplete type
EDIT:What is the error in my code? I have now tried compiling with GCC 4.4, 4.5 and 4.6, all resulting in the same error. Either no work has been done on this, or I did something wrong /EDIT
Thanks very much! If I'm not clear enough, I'll gladly elaborate.
PS: Could I work around this without tr1 stuff by using a function pointer to a function defined somewhere in myIntegrator.cpp?
FINAL UPDATE: ok, I was mistaken in thinking TR1 provided a one/two-line solution for this. Bummer. I'm "converting" my classes to namespaces and copypasting the function declarations. I only need one base class and one subclass which reimplemented the interface. C function pointer + C++ class = bad news for me.
Thanks anyways for all the answers, you've shown me some dark corners of C++ ;)
If you are just trying to pass a member function into a c-style callback, you can do that with out using std::t1::bind or std::tr1::function.
class myIntegrator
{
public:
// getValue is no longer const. but integrandF2 wasn't changed
double getValue( double x, double Q2 )
{
m_x = x;
m_Q2 = Q2;
// these could be members if they need to change
const double xMin[3] = {0.0};
const double xMax[3] = {1.0,1.0,1.0};
const unsigned maxEval = 0;
double reqAbsError = 0.0;
double reqRelError = 1e-4;
double val;
adapt_integrate( 1, &myIntegrator::fancy_integrand,
reinterpret_cast<void*>(this),
3, xMin, xMax,
maxEval, reqAbsError, reqRelError,
&val, &m_err);
return val;
}
double get_error()
{ return m_error; }
private:
// use m_x and m_Q2 internally
// I removed the unused void* parameter
double integrandF2( unsigned ndim, const double *x,
unsigned fdim, double *fval) const;
static double fancy_integrand( unsigned ndim, const double* x, void* this_ptr,
unsigned fdim, double* fval)
{
myIntegrator& self = reinterpret_cast<myIntegrator*>(this_ptr);
self.integrateF2(ndim,x,fdim,fval);
}
double m_x
double m_Q2;
double m_err;
};
You have three problems... first you want a std::tr1::function<R (Args..)>, but yours boils down to std::tr1::function<R (*)(Args...)> - so you need two typedefs:
typedef void (integrand) (unsigned ndim, const double *x, void *,
unsigned fdim, double *fval);
typedef integrand* integrand_ptr;
... so the first allows you a compilable function<integrand>. adapt_integrate has to be fixed accordingly:
int adapt_integrate(unsigned fdim, integrand_ptr f, ...);
Next your bind syntax is off, it should be:
std::tr1::bind(&myIntegrator::integrandF2, *this, _1, _2, _3, _4, _5);
The remaining problem is that tr1::function<T> isn't convertible to a function pointer, so you would have to go through a wrapper function, using the void* fdata argument to pass the context. E.g. something like:
extern "C" void integrand_helper (unsigned ndim, const double *x, void* data,
unsigned fdim, double *fval)
{
typedef std::tr1::function<integrand> Functor;
Functor& f = *static_cast<Functor*>(data);
f(ndim, x, data, fdim, fval);
}
// ...
adapt_integrate(1, &integrand_helper, &func, ...);
This is of course assuming that the void* parameter is passed through to the function, if not it would get ugly.
On the other hand, if void* fdata allows to pass context, all that tr1::function stuff is unnecessary and you could just go directly through a trampoline function - just pass this through as the context argument:
extern "C" void integrand_helper (unsigned ndim, const double *x, void* data,
unsigned fdim, double *fval)
{
static_cast<myIntegrator*>(data)->integrandF2(ndim, ...);
}
// ...
adapt_integrate(1, &integrand_helper, this, ...);
Since std::tr1::bind and c-style function pointers don't get along, try this instead. It will work, except that myIntegrator::getValue is not longer thread-safe. If calcTripleIntegral were removed from the interface, this would be even simpler and wouldn't need to use std::tr1::bind or std::tr1::function.
class myIntegrator
{
public:
double getValue( double x, double Q2 ) const
{
return calcTripleIntegral(x,Q2,std::tr1::bind(&Integrator::integrandF2,this));
}
double calcTripleIntegral( double x, double Q2, const std::tr1::function<integrand>& func ) const
{
assert( s_integrator == NULL );
s_integrator = this;
m_integrand = func;
//...declare val, err, xMin, xMax and input(x,Q2) ...//
adapt_integrate( 1, &myIntegrator::fancy_integrand, input,
3, xMin, xMax,
0, 0, 1e-4,
&val, &err);
assert( s_integrator == this);
s_integrator = NULL;
return val;
}
private:
double integrandF2( unsigned ndim, const double *x, void *,
unsigned fdim, double *fval) const;
static double fancy_integrand( unsigned ndim, const double* x, void* input,
unsigned fdim, double* fval)
{
s_integrator->integrateF2(ndim,x,input,fdim,fval);
}
std::tr1::function<integrand> m_integrand;
static const myIntegrator* s_integrator;
};
I want to pass a (non-static!) class member function as the integrand...
You can't. If you search SO for using member functions as callbacks you'll be bound to find useful information including the fact that what you're trying to do, the direct approach anyway, is not possible.
Edit: BTW, one of the problems in your code (there's more of course since what you're trying to do is simply not possible) is that you've passed a function pointer type to function<> when what it expects is a signature. The function template is implemented something like so:
template < typename Signature >
struct function;
// for each possible number of arguments:
template < typename R, typename Arg1, typename Arg2 >
struct function<R(Arg1,Arg2)>
{
... body ...
};
As you can see, passing a function pointer to this kind of thing is simply not going to be understood by the compiler. It's going to try to instantiate the forward declaration and get nowhere. This is of course what the compiler error you're getting means but it doesn't address your fundamental problem, which is that what you're doing will never work.
In a fully C++0x compiler this can be done differently but boost::function and the MSVC one has to be like this. Furthermore, the C++0x version is going to have the same problem that you currently are facing.
Making the assumption that the C-API allows passing a type-agnostic (in the sense that the C-API function doesn't have to know its type but relies on the callback function to know what it requires) context parameter (this is usually the case with callback functions; in this case I suspect the fdata parameter to be something along these lines), pass the function object as part of this context parameter.
It should then look something like this:
#include <iostream>
#include <tr1/functional>
typedef void (*callback_function_t)(void *input, int arg);
struct data_type {
int x;
};
struct context_type {
std::tr1::function<void(data_type const &, int)> func;
data_type data;
};
void callback(data_type const&data, int x) {
std::cout << data.x << ", " << x << std::endl;
}
void callback_relay(void *context, int x) {
context_type const *ctxt = reinterpret_cast<context_type const*>(context);
ctxt->func(ctxt->data, x);
}
void call_callback(callback_function_t func, void *context, int x) {
func(context, x);
}
int main() {
context_type ctxt = { callback, { 1 } };
call_callback(callback_relay, &ctxt, 2);
}
Where call_callback is the C-API function. This way, you can assign anything you want that supports function call syntax to context_type::func, including std::tr1::bind expressions. Also, even though (I feel morally obligated to mention this) it is not, strictly speaking, defined in the standard that calling conventions for C and C++ functions are the same, in practice you could make context_type a class template and callback_relay a function template to make context_type::data more flexible and pass anything you like this way.
That error message makes it sound like you're missing an include for one of the types involved. At least try double-checking your integrand and tr1 includes?
bind works a bit different than you assume I think. You either need to provide a value, or a placeholder for every argument.
For your example this boils down to (with placeholders)
std::tr1::function<integrand> func(std::tr1::bind(&myIntegrator::integrandF2, *this, _1, _2, _3, _4, _5));
Since you're binding a member function, you got an extra (implicit) argument, i.e. the object you call the member function on, so you have six.
For the first you bind the this object, for the other arguments you simply pass placeholders.
On a side note, your member function returns double, while the function declaration returns void.
(for the record, I'm still using an older compiler with little tr1 support, so I only have bind and function experience from using boost, maybe things changed a little for tr1...)
I have got a problem with calling a global function, which takes a pointer to a function as a parameter.
Here is the declaration of the global function:
int lmdif ( minpack_func_mn fcn, void *p, int m, int n, double *x,
double *fvec, double ftol)
The "minpack_func_mn" symbol is a typedef for a pointer to a function, defined as:
typedef int (*minpack_func_mn)(void *p, int m, int n, const double *x,
double *fvec, int iflag );
I want to call the "lmdif" function with a pointer to a function which is a member of a class I created, and here is the declaration of this class function:
int LT_Calibrator::fcn(void *p, int m, int n, const double *x,
double *fvec,int iflag)
I am calling a global function like this:
info=lmdif(<_Calibrator::fcn, 0, m, n, x, fvec, ftol)
Unfortunately, I get a compiler error, which says:
"error C2664: 'lmdif' : cannot convert parameter 1 from 'int (__thiscall LT_Calibrator::* )(void *,int,int,const double *,double *,int)' to 'minpack_func_mn'
1> There is no context in which this conversion is possible"
Is there any way to solve that problem?
It looks to me like the lmdif function takes the "void *p" as a user argument that it just passes to the callback (minpack_func_mn fcn).
If that is the case, just make LT_Calibrator::fcn a static function, and pass your object as the "p" parameter. Then you can cast the user-argument (p) to get your object back, if you want.
class LT_Calibrator
{
public:
static int fcn(void *p, int m, int n, const double *x, double *fvec,int iflag)
{
LT_Calibrator* pCalibrator = static_cast<LT_Calibrator*>( p );
}
};
Then call like:
LT_Calibrator someCalibrator;
info=lmdif(<_Calibrator::fcn, &someCalibrator, m, n, x, fvec, ftol);
Essentially there is an implicit argument for a member function (the this pointer) which makes this tricky. Check out this FAQ entry for more information.
You need a non-member or static member function; a member function pointer can't be used in place of your function type because it requires an instance to call it on.
If your function doesn't need access to a LT_Calibrator instance, then you can simply declare it static, or make it free function. Otherwise, it looks like you can use the first argument (void *p) to pass an instance pointer into a "trampoline" function, which can then call a member function. Something along the lines of this:
// member function
int LT_Calibrator::fcn(int m, ...);
// static (or non-member) trampoline
static int fcn_trampoline(void *p, int m, ...)
{
return static_cast<LT_Calibrator*>(p)->fcn(m,...);
}
info = lmdif(&fcn_trampoline, this, m, ...);