Question

I want a templated class with a templated conversion operator and a default constructor, but my initial attempt isn’t working.

template<typename T>
class C
{
public:
    C() {}

    template<typename U>
    operator U() 
    {
        C<U> c; // (*)
        c._a = dynamic_cast<U*>(_a); 
        return c;
    }
private:
    T* _a;
};

But now, when I try to create an instance of C,

template<typename T>
void F()
{
    ...
    C<T> obj;
}

operator U() keeps calling itself over and over at (*), eventually segfaulting. The same thing happens when I define the function that does the casting externally and call it from operator U()–in which case there is no call to C::C() from within the class definition.

It seems to me then that the conversion operator is getting called when I want the default constructor called–it is essentially trying to convert itself. But surely, there’s a way to do what I’m trying to do?

Answer 1

Note that in operator X (where X is a type) functions, you should usually return something of type X. You’re returning a C<U> when you’re trying to convert the invoking object to a U which causes the following to happen:

1. int a = someC; (where someC is a C of any type) will try to assign a C<X> to an int
2. operator T<int> will be called on someC which will return a C<int> and then try to assign it to an int
3. operator T<int> will be called on the aforementioned return value which will return a C<int>
4. That return value which is a C<int> will attempt to be converted to an int which will call operator T<int>….
5. goto 3;

Hopefully you can see why the infinite recursion and subsequent stack overflow occurs.

You cannot return a C<U> from operator T<U> of class C. You need to redesign your class if you need to for some reason.