How to specialized the template function when its parameter type are same?

[skydoom]

template <class A, class B> inline B* mycast( A* a)
{
return dynamic_cast<B>(a);
}

// try to specialize the mycast to handle when B==A, such as:
template <class A> inline A* mycast(A* a)
{
return a; // since type B is identical to A.
}
// OR what else I should do to implement this function??????

//....somewhere we try to use mycast()
test()
{
A* ap;
B* bp = mycast(ap); // I expect this will call the primary template function.

A* ap2 = mycast(ap); // I expect this will call the specialized tuned template function.
}

// unfortunately, above code is not run as I expected.

As a "derived question" from above, is the "dynamics_cast<A>(a)" EXACTLY(performance??) idential to "A(a)" when a is type of "A"???

[RRick]

The second template definition is not a specialization of the first, rather it is a new (and different) definition.

Another problem you're going to run into is that both of your templated functions differ only by the return value. When the compiler see these two definitions, it will not use the return value in its comparison. In this case, it won't know which one to pick.

You can get around this ambiguity by explicitly defining which mycast function you want used, but this probably defeats the purpose of what you're trying to do. For example,

Derive* dPtr = mycast<Base,Derive>( bPtr);
Base* bPtr2 = mycast<Base>( bPtr);

[skydoom]

I had fingered out what I should do now :)

Indeed, I initially want some 'partial template specialization' for the template function, which is not currently supported in the C++ standard(which _might_ be in the next C++0x). But I do find some workaround for that:

// declare a template class with a friend template function.
template<typename B, typename D>
class mycast{
friend D* fun_cast<B,D>(B* b);
public:
D* operator ()(B* b)
{
return dynamic_cast<D*>(b);
}
private:
~mycast(){}
};

// !!!! partial specialization for the "SAME TYPE" casting.
template<typename D>
class mycast<D,D>{
friend D* fun_cast<D,D>(D* b);
public:
D* operator ()(D* b)
{
return b;
}
private:
~mycast(){}
};

// This is the interface to the user, the template function below will use the correct one.
template < typename B, typename D>
D* fun_cast(B* b)
{
return mycast<B,D>()(b);
}

Thanks anyone.

PS. As the last question, how's the performance for dynamics_cast<A*>(a), while a is indeed of type A? (is it identical to the A(a) by the compiler?)