By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
435,319 Members | 1,963 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 435,319 IT Pros & Developers. It's quick & easy.

Function pointers

MrPickle
100+
P: 100
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?
Mar 1 '09 #1
Share this Question
Share on Google+
11 Replies


weaknessforcats
Expert Mod 5K+
P: 9,197
If you have a function pointer named fp and you use it this way:

Expand|Select|Wrap|Line Numbers
  1. int x = fp(3,4);
  2. 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.
Mar 1 '09 #2

MrPickle
100+
P: 100
So you have to define the arguments?

Is there anyway around this, like using void pointers?
Mar 1 '09 #3

Expert 10K+
P: 11,448
@MrPickle
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
Mar 2 '09 #4

Expert 100+
P: 2,400
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:
Expand|Select|Wrap|Line Numbers
  1. #define FNULL 0L
Mar 2 '09 #5

MrPickle
100+
P: 100
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?
Mar 2 '09 #6

weaknessforcats
Expert Mod 5K+
P: 9,197
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:

Expand|Select|Wrap|Line Numbers
  1. 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.
Mar 2 '09 #7

MrPickle
100+
P: 100
Thank you, I will take a look at the STL functions and then play a little.
Mar 2 '09 #8

MrPickle
100+
P: 100
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:
Expand|Select|Wrap|Line Numbers
  1. template <class In, class Op> Op for_each(In first, In last, Op f)
  2. {
  3.     while(first != last) f(*first++);
  4.     return f;
  5. }
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.
Mar 3 '09 #9

100+
P: 147
@MrPickle
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++.
Mar 4 '09 #10

weaknessforcats
Expert Mod 5K+
P: 9,197
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.
Mar 4 '09 #11

MrPickle
100+
P: 100
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...bind/bind.html

Thanks all.
Mar 5 '09 #12

Post your reply

Sign in to post your reply or Sign up for a free account.