function template overloading

[presencia]

Hi all,

i would appreciate help with the following problem: Please consider the code

#include <iostream>
using namespace std;
 
template<typename T> struct A{};
template<typename T> struct B: public A<T>{};
 
template<typename T> void f(T obj){ cout << "default\n"; }
template<typename T> void f(A<T> obj){ cout << "special case\n"; }
 
int main(){
    A<int> a;
    f(a);
    B<int> b;
    f(b);
}
 

This code compiles fine and produces the output

special case
default

As you can see - and I guess that is the way it is supposed to work - the special case implementation is only used if the template fits exactly, not by inheritance.

What I would like to do, however, is specify function f for the special case that it is called with parameter of type A<T> or B<T> for any type T and any child B of A.

Is there a way to do this? Or do I have to write another template (with the same code) for the case f(B<T> obj)?

Any advise appreciated, I can't think of a good way.

~<><~~~~~~ presencia

[weaknessforcats]

You will need to make function f a memeber function for the special case.

[presencia]

I am sorry I don't get it right away. What class should f be a member of?
Why exactly do I have to make it a member function?
And can I still call it the same way as the default version? (i.e., like: f(obj) )

Thanks for your time!
~<><~~~~~~~~ presencia

[weaknessforcats]

Is this what you had in mind? I'm not sure I have your program requirements correctly understood.

template<typename T> struct A
{
    virtual void f(A<T> obj){ cout << "special case\n"; } 
 
}; 
template<typename T> struct B: public A<T>
{
    virtual void f(A<T> obj){ cout << "special case\n"; } 
 
}; 
 
template<typename T> void f(T obj){ cout << "default\n"; } 
 
 
int main(){ 
    A<int> a; 
    a.f(a); 
    B<int> b; 
    b.f(b); 
    f(a);
    f(b);
} 

[presencia]

Thanks for your reply.
I am afraid, I didn't explain my problem well enough. So please let me try again:

I want to write a global function that does something. I want it to take one parameter of any type or class it can deal with. So I write a function template instead of a function, just like this:

//first function template f
template<typename T> void f(T obj){ /*do something*/ }

Everything works well for now. I can call function f with just any object.

But now I have a class template A:

template<typename T> struct A{};

and I would like f to behave differently if the parameter provided is of type A<T> for any typename T. So I want to overload f, just like this:

//second function template f
template<typename T> void f(A<T> obj){ /*do a different thing*/ }

Now, when I call f with an object of type A<T> like this

A<int> a;
f(a);

the code of the second function template f is executed, just as I wanted. But I want this "second version of f" to be executed if called with a parameter of type B<T> for any child B of A and any typename T, just like this:

template<typename T> struct B: public A<T>{};
B<int> b;
f(b);

However, executing the last code will call the FIRST version of function template f.

Now, there is a simple solution for this: I can just copy the code of template<typename T> void f(A<T> obj) and write function templates template<typename T> void f(B<T> obj) for all children B of A, all with the exact same code to be executed.

My question is: I there a way to produce the function f like I want it without making a copy of the code for every class derived from A?

Thanks for considering my question.
~<><~~~~ presencia

[weaknessforcats]

Try:

template<typename T> struct A
{
 
    virtual void f();
 
}; 
template<class T>
void A<T>::f()
{ cout << "A special case\n"; } 
 
template<typename T> struct B: public A<T>
{   
 
    virtual void f(); 
 
};
template<typename T>
void B<T>::f(){ cout << "B special case\n"; } 
 
template<typename T> void f(T& obj){ cout << "default\n"; } 
template<typename T> void f(A<T>* obj){ obj->f();}
 
 struct C
 {
 
 };
int main(){ 
    A<int> a; 
    B<int> b; 
    f(&a);
    f(&b);
    C c;
    f(c);
 
} 

The idea here is that when you call the global f using a pointer to get a virtual function call into the struct A hierarchy. That will call the correct f() for the child of A. When you call the global f() by reference, you get your default case.

Note the global f() overload uses a T& and an A<T>*.

You will not be able to overload the global f() using T and A<T>*. The pointer is seen as a T and you get the wrong template. However, a reference requires an object so the compiler sees A<T>* as a better fit than T& and picks the right template.

Does this work for you?

[hype261]

Even though this might not be an elegant solution to your problem you could always do this.

#include <iostream>
 
template<class T>
struct A
{
 
};
 
template<class T>
struct B : public A<T>
{
 
};
 
struct C
{
 
};
 
template<typename T>
void f( T & obj)
{
       std::cout << "default case" << std::endl;
}
 
template<typename T>
void f(A<T> & obj)
{
       std::cout << "special case" << std::endl;
}
 
template<typename T>
void f(B<T> & obj)
{
       A<T> * reference = dynamic_cast<A<T>*>(&obj);
       if(reference != 0)
       {
              f(*reference);
       }
}
 
int main()
{
 
       A<int> a;
       B<int> b;
       C c;
 
       f(a);
       f(b);
       f(c);
 
       return 0;
 
}
 

The benefit here is that you can use don't have to remember to include the address of operator if you want to call the A<T> or B<T> template versions.