Function pointers

[MrPickle]

Is it possible to have a function pointer without knowing the arguments of the function?

All tutorials I have read have declared the function pointer like so:
int (*func)(int, float);

could that just be declared as
int (*func);

or would the compiler assume that there is no arguments?

[weaknessforcats]

If you have a function pointer named fp and you use it this way:

int x = fp(3,4);
float y = fp(1.0,2.0);

which is correct? Does the function pointed at by fp have two int arguments returning an int or two double arguments returning a float?

Unless the arguments and return type are specified in the function pointer declaration, the compiler has no way to determine of you are calling function correctly.

[MrPickle]

So you have to define the arguments?

Is there anyway around this, like using void pointers?

[JosAH]

So you have to define the arguments?

Is there anyway around this, like using void pointers?

Yes, you have to define the type(s) of the argument(s) and the type of the return value of the function; both form the 'signature' of a function. A compiler needs to know what the signature of a function (pointer) is in order to be able to use it. You can lie to the compiler of course but you're on your own then.

No, you can't just use void pointers if the actual function doesn't expect void pointers as the types of its arguments.

kind regards,

Jos

[donbock]

I assume you are asking the question because you have a function pointer variable and you want it to point to different kinds of functions (ie, with differing prototypes) based on some criteria. You're confident that you will know which kind of function is pointed to (ie, what arguments to pass) when it is time to call the function being pointed at.

1. I recommend you use several function pointer variables -- one for each logically different kind of function.

2. If you insist on a single function pointer then you could look into declaring a union of function pointers.

3. If this is some kind of C riddle, then perhaps the answer is to declare the function pointer with ellipsis and then cast to and from the actual prototype. This approach is definitely NOT recommended if you care whether your software works or not.

4. Keep in mind that function pointers and data pointers are very different things. You cannot reliably convert from one to the other -- regardless of whether you can find a way to suppress compiler warnings. A corollary of this is that you should never assign NULL to a function pointer. If you need a null function pointer value then construct it for yourself:

#define FNULL 0L

[MrPickle]

Ok thank you, I am using C++ by the way.

Could you use a template of some sort, to give the function pointer some dynamics?

[weaknessforcats]

Look at the implementation of the C++ STL. You have generator functions (no arguments), unary functions (one argument) and binary functions (two arguments) and that's all.

If you need 10 arguments you need to create ano object with 8 of the arguments installed as member data and then the operator() can have the final 2arguments, which it can combine with the 8 data members to call your 10 argument function. The STL implements the binder1st and binder2nd classes to help you out.

There is, however, no simple general purpose solution. If you use a void* for your function pointer, you still have to typecast it to the correct function pointer which means you still have to specify the arguments and return type at some point.

When Microsoft implemented multi-threading and allowed you to create threads they published a thing called a THREADPROC:

DWORD WINAPI ThreadProc(LPVOID);

This meant that if your function is to become thread it must have one LPVOID argument and return a DWORD. Nothing else will work.

[MrPickle]

Thank you, I will take a look at the STL functions and then play a little.

[MrPickle]

Okay, so I've took a look at the STL functions but I can't see where the function pointer define's the arguments.

I'll take for_each as an example:

template <class In, class Op> Op for_each(In first, In last, Op f)
{
    while(first != last) f(*first++);
    return f;
}

I see no argument declaration for the function pointer, nor do I see a pointer declaration? (I copied the code from "The C++ Programming Language" by Bjarne Stoustrup so I'm 99% sure it's correct.

[scruggsy]

Okay, so I've took a look at the STL functions but I can't see where the function pointer define's the arguments.

I'll take for_each as an example:

template <class In, class Op> Op for_each(In first, In last, Op f)
{
    while(first != last) f(*first++);
    return f;
}

I see no argument declaration for the function pointer, nor do I see a pointer declaration? (I copied the code from "The C++ Programming Language" by Bjarne Stoustrup so I'm 99% sure it's correct.

You see nothing about function pointers there because foreach is a template function. You can instantiate it with any type for f so long as calling f(*first++) is a legal operation. This means f must be a function taking one argument or an object of a class with an overloaded operator()() method taking one argument. Moreover because first is of type In, f must take an argument convertible to whatever type In is when the template is instantiated. (Similarly, first and last must be of a primitive or user-defined type which supports the *, !=, and ++ operators).

You may want to look into templates along with the STL and its notion of functors and predicates; you're likely to make heavy use of them if you do much work in C++.

[weaknessforcats]

You may want to look into templates along with the STL and its notion of functors and predicates; you're likely to make heavy use of them if you do much work in C++.

OP: A functor is a class implementing the function operator. That is, it implements operator() as a member function. That operator() can have zero, one or two arguments only.

Those are the generator, unary and binary functions.

If your unary function returns true or false, then it is called a predicate.
If your binary function returns true or false, then it is called a binary predicate.

You have to be clear on this since the STL documentation uses these terms, often without explanation. That is, when you read binary predicate your are to understand that you need to provide the address of a function that takes two arguments and returns a bool.

[MrPickle]

I have learnt of something in the boost libraries, boost::bind, it fits this purpose beautifully. Just letting everybody know of it for in the future.

http://www.boost.org/doc/libs/1_38_0/libs/bind/bind.html

Thanks all.