Question

Suppose I have class D which inherits from class B. and I have a template class template <class T> C. And then I have a function signature void foo(C<B> c);. In order to make that work with an instance of C templated with a derived class from B do I need to provide a conversion constructor? Something like template <class DERIVED> C(const C<DERIVED>& c) {}? Will this be enough for anything else that happens in C since any D is a B?

Answer 1

C<D> and C<B> will not be related types at all, so yes, you’d have to provide a conversion that allows a C<B> to be constructed from a C<D>.

This probably will not make the types perfectly compatible. For example a function void foo(C<B> &c) will not be able to use that conversion.

Whether these unrelated types can be made compatible enough for your uses depends on how you define the types and what you need from them in terms of compatibility.

---

struct B {};
struct D : B {};

template<typename T>
struct C {};

int main() {
    C<B> c = C<D>();
}

---

test1.cpp:9:10: error: no viable conversion from 'C<struct D>' to 'C<struct B>'
    C<B> c = C<D>();
         ^   ~~~~~~

Consider this example for why there should not be any relationship between different specializations of a template:

struct B {};
struct D : B {};

template<typename T> struct C;

template<> struct C<B> { int i; }; // different specializations
template<> struct C<D> { double a, b, c; }; // can have different definitions

Converting between types related by inheritance works because a derived type always has a sub-object of the base type. Even so, types that use inheritance must be carefully designed in order to work well.

---

User defined conversions operate via non-explicit constructors and type operators:

struct T {};

struct S {
    S() {}
    S(T const &) {}
    operator T () { return T(); }
};

void foo(T t) {}
void bar(S s) {}

int main() {
    foo(S()); // uses S::operator T ()
    bar(T()); // uses S::S(T const &)
}

You can read more in the standard 12.3.2 Conversion functions [class.conv.fct] and about how they are used in overload resolution 13.3 Overload resolution [over.match].