C++ Conversion operator for converting to function pointer

Question

I'm been grinding my head against an idea that is simple enough in my head, but I can't figure out how to implement in C++.

Normally, I can declare a class with a conversion operator like in this simple example:

class Foo { private: int _i; public: Foo( int i ) : _i(i) { } operator int( ) const { return i; } };

So now I can write awesome stuff like

int i = Foo(3);

But in my particular case, I would like to provide an operator for converting an object to a function pointer (e.g. converting a Bar instance to a int(*)(int, int) function pointer). Here's what I initially tried:

class Bar { private: int (*_funcPtr)(int, int); public: Bar( int (*funcPtr)(int, int) ) : _funcPtr(funcPtr) { } operator int(*)(int, int) ( ) const { return _funcPtr; } };

But the operator function fails to compile, with these errors being generated:

expected identifier before '*' token '<invalid-operator>' declared as a function returning a function

I have also tried simple variations on the above, such as surrounding the return type in parenthesis, but all these ideas have also failed.

Does anyone know what the syntax is for declaring a conversion-to-function-pointer operator method, or whether it is even possible to do so?

Note: I am compiling this with Code::Blocks using GCC 4.5.2. Answers involving some of the new C++0x concepts are also welcome.

Edit

In my strive for simplifying the example, I unintentionally left out one detail. It's a bit weird, but rather than strictly returning an int(*)(int,int) pointer, the conversion operator is intended to be templated:

template<typename ReturnType, typename ArgType1, typename ArgType2> operator ReturnType(*)(ArgType1, ArgType2) ( ) const { // implementation is unimportant here }

As far as I know, I no longer cannot typedef such a type. This clearly makes things much more clumsy, but I hope that there is still a way.

try typedef'ing the return type: "typedef int (*ptr_t)(int,int);" then, return an object of type "operator ptr_t () const" — J T
– J T, Commented Jul 20, 2011 at 0:25
@J T: I am doing something similar to boost::function but it has a very distinct behavior. I originally looked at using boost::function, but unfortunately I did not find it a suitable choice. — Ken Wayne VanderLinde
– Ken Wayne VanderLinde, Commented Jul 20, 2011 at 0:54

Kerrek SB · Accepted Answer · 2011-07-22 22:06:51Z

20

Since you must know:

(*operator int() const)(int, int) { return _funcPtr; }

(Fixed. Again.)

Update: I've been informed by Johannes Schraub and Luc Danton that this syntax is in fact not valid, and that you really must use a typedef. Since you say that typedefs aren't an option, here's a helper class that can wrap your typedef:

template<typename R, typename A1, typename A2> struct MakeFunctionType { typedef R(*type)(A1, A2); }; template<typename R, typename A1, typename A2> operator typename MakeFunctionType<R, A1, A2>::type () const { // implementation is unimportant here }

edited Jul 22, 2011 at 22:06

answered Jul 20, 2011 at 0:36

Kerrek SB

481k96 gold badges904 silver badges1.1k bronze badges

Sign up to request clarification or add additional context in comments.

11 Comments

J T Over a year ago

this doesnt help with the template case he mentions

Kerrek SB Over a year ago

No, that was before the edit, but that should be straigth-forward to generalize to template<typename R, typename... Args> (*operator T() const)(Args...).

Ken Wayne VanderLinde Over a year ago

Thank you very much. Function pointer syntax can sometimes be quite confusing, especially in a scenario it seems that not many people use, and one in which typedefs are not applicable. Any chance I can get an explanation of why it looks that way? My idea is that operator int() const is the name of the function, so it is placed inside the parenthesis and preceded by an asterisk. Then, as usual for conversion operators, we drop the return type, since it is part of the name already. Is this the correct reason for the syntax?

Kerrek SB Over a year ago

The basic principle is that you always wrap the identifier of the final object in parentheses and append the arguments in another set of parentheses at the end: If the function signature is R(S, T), then a function pointer is R(*myfp)(S,T) (and the actual function type is R()(S,T)). Now we apply that thinking to operator A() const with A = R(*)(S,T) to get (*???)(S,T), where ??? = operator R() const. Think of passing from "type R" to "function returning type R".

Kerrek SB Over a year ago

Yeah, use a helper: <template typename R, typename... Arg> struct MakeMyFP { typedef R(*type)(Args...); };, then say <template typename R, typename... Args> operator typename MakeMyFP<R,Args...>::type () const.

|

Nemo · Accepted Answer · 2011-07-20 01:05:22Z

4

Use a typedef. It's easier to read, anyway:

class Bar { public: typedef int (*fptr_t)(int, int); Bar(fptr_t funcPtr) : _funcPtr(funcPtr) { } operator fptr_t() const { return _funcPtr; } private: fptr_t _funcPtr; };

[edit]

For your template case I do not see how to use a typedef. @Kerrik gives the (messy) version of the syntax that should work.

edited Jul 20, 2011 at 1:05

answered Jul 20, 2011 at 0:25

Nemo

71.9k11 gold badges125 silver badges160 bronze badges

4 Comments

Chris Over a year ago

Assuming the above works, is there a way without a typedef? Just curious; I agree the typedef makes much more sense.

Ken Wayne VanderLinde Over a year ago

Hi, thanks for the answer. You'll see that I edited my question, as I left out a small, yet super-important detail about my use of templates. Could I still harness the simplicity of a typedef in this case?

Nemo Over a year ago

@J T - I think I posted my answer 15 minutes before you posted yours. Also 5 seconds before you posted your comment. (Wave your mouse over the times to see them in hours:minutes:seconds)

Johannes Schaub - litb Over a year ago

@JT and it can't happen that Nemo just answers this without reading your answer before? Why are you assuming he "steals" your answer? That's childish.

J T · Accepted Answer · 2011-07-20 00:53:31Z

EDIT:

Since your class has a non template function pointer assigned at constuction:

private: int (*_funcPtr)(int, int);

It is not at all possible to later convert that to a function pointer of any type.

I will therefore assume that you meant a template class member operator overload, not a class template member operator overload.

Template version:

template<typename ReturnType, typename ArgType1, typename ArgType2> class Bar { public: typedef ReturnType (*fptr_t)(ArgType1, ArgType2); operator fptr_t ( ArgType1 arg1, ArgType2 arg2 ) const { // implementation is unimportant here } //etc... };

Then used like this:

//create functor to some function called myfunc Bar::fptr_t func_ptr = Bar<int, int, int>(&myfunc); //call functor int i = func_ptr(1,2);

This is a class template with a member function. It looks like he wants a real class with a member function template.
@J T: aschepler is exactly right. The same instance of Bar must be convertible to many different types of function pointers, so templating the class is not an option. And if anyone suggests it, I also cannot convert to templated functor type, it must be an actual function pointer.

Matthieu M. · Accepted Answer · 2011-07-20 06:56:29Z

If you want to make the code readable, you need to use a typedef. I don't even use functions pointers without typedef'ing them, the syntax is too horrid.

Goal:

template<typename ReturnType, typename ArgType1, typename ArgType2> operator ReturnType(*)(ArgType1, ArgType2) ( ) const { return 0; }

Path:

// 1: helper structure template <typename R, typename A0, typename A1> struct helper { typedef R (*type)(A0,A1); }; // 2: operator template <typename R, typename A0, typename A1> operator typename helper<R, A0, A1>::type() const { return 0; }

Check it out on ideone!

You're definitely right about the syntax being awful. It would've been nice to have a cleaner syntax, but I suppose we would probably end up using typedefs anyways.

llf · Accepted Answer · 2018-08-03 18:49:05Z

In C++11, it is possible to use an alias template to convert to any function, bypassing the need for custom type trait structs.

class Bar { private: template<typename ReturnType, typename ArgType1, typename ArgType2> using funcptr = ReturnType(*)(ArgType1, ArgType2); public: template<typename ReturnType, typename ArgType1, typename ArgType2> operator funcptr<ReturnType, ArgType1, ArgType2> ( ) const; };

To limit this to just int(*)(int, int), we can use SFINAE or static_assert.

Vladimir Reshetnikov · Accepted Answer · 2017-05-03 00:48:34Z

The following works in GCC:

template<typename ReturnType, typename ArgType1, typename ArgType2> operator decltype((ReturnType(*)(ArgType1, ArgType2)) nullptr)() const { // ... }

Collectives™ on Stack Overflow

C++ Conversion operator for converting to function pointer

Edit

6 Answers 6

11 Comments

4 Comments

2 Comments

1 Comment

Comments

Comments

Linked

Hot Network Questions

Collectives™ on Stack Overflow

Edit

6 Answers 6

11 Comments

4 Comments

2 Comments

1 Comment

Comments

Comments

Linked

Related