Differentiating 2 methods with the same name for a pointer

Code o mat

You mean with the explicit conversion, right? Currently i am unable to test it in runtime because it is part of a bigger project and i still need to do a lot of work before it becomes "runnable". An alternative solution for me could be to create another method (or two methods) with different names and same parameters and then from these call the right Func, but this isn't that elegant (but still less problematic than renaming the functions everywhere)... I mean something like this:

int Func1(int x) { return Func(x); }
int Func2(int x, int y) { return Func(x, y); }
...
FUNC_ONE pFuncOne = Func1;
FUNC_TWO pFuncTwo = Func2;

> The problem with computers is that they do what you tell them to do and not what you want them to do. < > Sometimes you just have to hate coding to do it well. <

molesworth

Code-o-mat wrote:

Currently i am unable to test it in runtime because it is part of a bigger project and i still need to do a lot of work before it becomes "runnable".

I always have a couple of simple "test apps" on my machines (one C++ and one C#) which I can slot things into to try out if I'm unsure of how to do them, or of usages, or to try simple versions of algorithms, or just to test ideas. Easy to set up, and very handy. :)

There are three kinds of people in the world - those who can count and those who can't...

Lost User

Code-o-mat wrote:

Currently i am unable to test it

Just paste it into a simple console app and call from main(), takes but a few minutes to test. Your alternative appears to be an equally good solution. Without knowing a lot more about your project it's difficult to offer much more advice. Either way you seem to have the answer at your fingertips. [edit]spelling[/edit]

Code o mat

I just realized i have made a mistake, in our project the two "same-name" methods have different return types while in the typedefs i used the same for both and this caused the conversion problem, not that it couldn't decide which version of the function to use. Fixing the typedefs seems to have solved it. My bad. :( Thanks for the help anyways, i guess i should pay more attenction to details...

> The problem with computers is that they do what you tell them to do and not what you want them to do. < > Sometimes you just have to hate coding to do it well. <

Code o mat

Thank you for the suggestion, i sometimes do that too, should have thought of it this time too, guess i am tired. Aside of this, see my other post[^] for the "solution"...

> The problem with computers is that they do what you tell them to do and not what you want them to do. < > Sometimes you just have to hate coding to do it well. <

Lost User

I think your signature(s) say it all. :laugh: I'm sure you'll get it right after a good night's sleep ... and maybe some beer.

SimonSays

In your first example, the one without the C-style cast, the type system should prevent you from performing an illegal assignment -- in other words the right thing would have to happen or a compiler error be generated. Because the compiler will not allow the following: typedef int(* FUNC_ONE)(int); int Func2Parm(int x, int y) { return x + y; } FUNC_ONE pFuncOne = Func2Parm; Once you introduce the explicit cast, I am not sure what will happen. I would have guessed that the compiler would report an ambiguity error (after all it could cast either pointer that way).

Moak

Code-o-mat wrote:

I declare two function pointer types [...]

Have you considered using C++ virtual functions[^]... just a suggestion. :)

Webchat in Europe :java: (only 4K)

Code o mat

Thanks for the suggestion but i don't see how that would apply to this situation.

> The problem with computers is that they do what you tell them to do and not what you want them to do. < > Sometimes you just have to hate coding to do it well. <

Moak

Well, when I saw function pointers I thought that the design pattern you try to implement is something like a callback or interchangeable functionality. In object oriented languages, polymorphism (virtual functions or delegates) provides exactly that and under the hood they are more or less function pointers, with the advantage that the compiler takes care of most things automatically (type safety, calling context). It could be worth to have a look at these possibilities. For using virtual functions define a interface (pure virtual base class) that you can override:

class IFunctionInterface
{
public: virtual int Func(int x) = 0;
public: virtual int Func(int x, int y) = 0;
};

class CFunction1 : public CWhatever, public IFunctionInterface
{
public:
CFunction1 ();
virtual ~CFunction1 ();

int Func(int x) { return x; }		//implementation of interface
int Func(int x, int y) { return x + y; }

};

class CFunction2 : public CWhatever, public IFunctionInterface
{
public:
CFunction2 ();
virtual ~CFunction1 ();

int Func(int x) { return x + x; }	//different implementation of interface!
int Func(int x, int y) { return x \* y; }

};

For delegates have a look at Boost library (function/bind/signal) or Fast C++ Delegates[^] here at CodeProject. Hope this helps. :) /M

Webchat in Europe :java: (only 4K)