Template const/non-const argument cast

Question

I went through some searches but couldn't quite find this one. Consider this situation:

template <class T> class TemplClass;
void a_function(TemplClass<const X>&);

TemplClass<X> inst;
a_function( inst ); // fails

"invalid initialization of reference of type ‘TemplClass&’ from expression of type ‘TemplClass’"

The situation is 100% safe as far as I can tell. Still, C++ does not allow this. So I wonder what cast to use instead of the trivial C-cast.

a_function( static_cast<TemplClass<const X>&>(inst) ); // fails, similar error message

a_function( reinterpret_cast<TemplClass<const X>&>(inst) ); // works

dynamic_cast is out of the question, const_cast fails too (and rightly so).

The reinterpret_cast feels fishy (is it though?). But is there a solution with some kind of trick that I missed? Anyone know why the standard does not simply detect that this is something good? Or is there something 'bad' about this cast?

Answer 1

TemplClass<const T> and TemplClass<T> are unrelated types.

For example you may have (partial) specialization to make them really different:

template<typename T>
class TemplClass
{
    void generic();
    std::string s;
};

template<typename T>
class TemplClass<const T>
{
    void foo();
    std::vector<int> v;
};

Casting one into the other doesn't make sense.

In the same way

class A
{
    char* p;
};

class B
{
    char* p;
};

Those 2 classes are unrelated (even if it seems identical).

Answer 2

But is there a solution with some kind of trick that I missed?

The ideal solution is to not write such restricted template interfaces. For example, consider the standard library algorithms that take iterators to represent ranges rather than specific template types with specific object types.

If you're unable to fix the interface as it's say in a third party library, then you're going to be stuck copying your Templ<X> to a Templ<const X> before making the call.

Anyone know why the standard does not simply detect that this is something good?

Because it's not good. The very simplest case is where there are template specializations where it would change some meaning/functionality. The compiler can't simply change the instantiation of the template.

Or is there something 'bad' about this cast?

By the language, the cast is illegal because the const and non-const template instantiations are unrelated types. Depending on the actual case, there are probably legal alternatives.