Overloaded function parameter matching

Hi, I'm trying to implement a mechanism which is supposed to select an appropriate overloaded function.

1. There is a base (template if it matters) class "base_class".
2. There are many other classes that inherit from base_class or do not.

Now, I have a function which operates on a pointer to base_class.

Code:

---

void Foo(base_class<T>* ptr)
{
    // do something with ptr
}
void Foo(void* ptr)
{
    // do not do anything
}

---

Now let's define some classes:

Code:

---

class ClassA : public base_class<T> {
// inherits
};

class ClassB {
// does not inherit
};

ClassA* a;
ClassB* b;

---

For those, which inherit from base_class, a call to Foo should resolve to Foo(base_class<T>*), but for those which do not, it should resolve to Foo(void*).
void* can be any type, since it is a dummy parameter.

For example:

Code:

---

Foo(a);  // should call Foo(base_class<T>*)
Foo(b);  // should call Foo(void*)

---

My problem is: this code is not working as expected. For some classes compiler chooses the proper overload, but not for the others. I'm using GCC 4.4.0 (having similar results on Borland's 5.6).

I tried many variations of templates, global functions, and structs. No RTTI, ClassB can be any type, including STL and fundamental types.

Any ideas?
Thanks.

Do you have a specific example of one that works opposite the way you think it should? (One that "misses" in both compilers, even?)

May-be a more complete example of where it doesn't work?

Ok, so I have finally managed to provide a smallest non-compilable example. I've modified my library a bit and figured out that the compiler has problems with matching parameters to the first overload.

Code:

---

////////////////////////////////////////////////////////////////////////////////

#include <iostream>
////////////////////////////////////////////////////////////////////////////////
template <class T>
class HelperClass {
};
////////////////////////////////////////////////////////////////////////////////
template <class T>
class BaseClass {
public:
    void CallMe()
    {
        std::cout << "BaseClass::CallMe()" << std::endl;
    }
};
////////////////////////////////////////////////////////////////////////////////
template <typename T>
void Foo(T* Ptr, HelperClass<T>* Helper, BaseClass<T>* Base)
{
    Base->CallMe();
}
////////////////////////////////////////////////////////////////////////////////
class ClassA : public BaseClass<ClassA> {
public:
};
////////////////////////////////////////////////////////////////////////////////
class ClassB {
public:
};
////////////////////////////////////////////////////////////////////////////////
#ifdef __BORLANDC__
#pragma argsused
#endif
int main(int argc, char* argv[])
{
    ClassA* a;
    ClassB* b;
    HelperClass<ClassA>* helper_a;
    HelperClass<ClassB>* helper_b;

    std::cout << "Calling Foo(a)..." << std::endl;
    Foo<ClassA>(a, helper_a, a); // !A!
    std::cout << "Calling Foo(b)..." << std::endl;
    Foo<ClassB>(b, helper_b, b); // !B!

    std::system("pause");
    return 0;
}
////////////////////////////////////////////////////////////////////////////////

---

I'm getting the following:

Code:

---

no matching function for call to 'Foo(ClassA*&, HelperClass<ClassA>*&, ClassA*&)'
no matching function for call to 'Foo(ClassB*&, HelperClass<ClassB>*&, ClassB*&)'

---

The second message is obvious, since ClassB is not a descendant of BaseClass<ClassB>.
But why are there any problems with the first call?

EDIT:
This example does not compile on both compilers, maybe I have missed some standards or there is just an obvious mistake?

EDIT2:
I made a stupid mistake, but it still does not work (updated code).

Error 1 error C2664: 'Foo' : cannot convert parameter 2 from 'HelperClass<T>' to 'HelperClass<T> *'
Error 2 error C2664: 'Foo' : cannot convert parameter 2 from 'HelperClass<T>' to 'HelperClass<T> *'

I've just noticed it, but it still does not work. Are you compiling it on MSVC?

You're missing an overload:

Code:

---

template <typename T>
void Foo(T* Ptr, HelperClass<T>* Helper, void* Base) {}

---

And make HelperClass into a reference or take the address of your objects. It will compile.

Thanks, it solved the example's problem and it indeed works. My real code is a bit different and there is a one-parameter member method, which also works. But still, from all of the classes which inherit from BaseClass, strangly, the compiler selects the second overload in some cases. I have to deal with it on my own.

Remember that your base class is templated. The 3rd parameter must specifically inherited from BaseClass<T> where T is the type of the first argument. Otherwise the compiler will select the second overload.

After 2 days I've finally fixed it - this was happening (am not sure - probably) because the HelperClass equivalent (or maybe a different one) wasn't defined at the point of the Foo function definition. I put the Foo call into the file where every class is supposed to be fully known and now everything seems to be working.