std::variant of template specializations converting move constructor - c++

Question

I am using a class that encapsulates an std::variant of template specializations, such as:
template<typename Type> struct Generic_node {...};
struct Leaf_node : Generic_node<...> {...};
struct Inner_node : Generic_node<...> {...};
struct Node {std::variant<Leaf_node, Inner_node> variant_;};
I am trying to construct a Node from a function in Generic_node using a converting move constructor, but the compilation fails.
I defined a template constructor, which accepts an rvalue reference (assuming one of the specialized classes) and constructs the variant by moving the value to the variant, where I expect to call the converting move constructor # (4).
When i was trying to create minimal non-working example, i found that the problem really shows only from the template function, where if I knew the exact type (Leaf_node == Generic_node<...> which the compiler knows), the move construction would succeed. Therefore I assume there is as always some template magic happening that I did not anticipate.
#include <variant>
template<typename T>
struct Base
{
void f();
};
struct Derived : Base<int> {};
struct Variant
{
// In real program expecting the T to be one of the multiple variants
// Here I use only one variant because it suffices to illustrate the problem
template<typename T>
Variant(T&& t)
:
variant_ {std::move(t)}
{
}
std::variant<Derived> variant_;
};
template<typename T>
void
Base<T>::
f()
{
Variant {std::move(Derived {})}; // can call on exact type
Variant {std::move(Base<T> {})}; // can not call on specialized template type
}
int
main()
{
Derived {}.f();
}
Relevant compiler error message (clang 7, libstdc++-8):
note: candidate template ignored: substitution failure [with _Tp = Base<int>,
$1 = void, $2 = void]: implicit instantiation of undefined template
'std::variant<Derived>::__to_type_impl<18446744073709551615, false>'
variant(_Tp&& __t)
The problem most probably does not have anything to do with variants, but with the equality of Base<T> == Derived in the template instantiation of the Variant constructor, which the compiler as if did not see.
What is happening in the template instantiations, why can't the compiler call the provided constructor?
Edit: Since I intended to create a specialization, I forgot that inheritance can not imply class type equality, even if it technically is in this special case. This is therefore an easy task of constructing Derived by move from the specialized Base:
struct Derived : Base<int>
{
Derived() = default;
Derived(Base<int>&&) {}
};
If I am correct, the constructor needs to be explicitly defined for each derived class of Base.

Answer 1

In the example you are giving, the Derived class is a separate class from Base. They have exactly the same members, same methods, but they are still separate classes.
Easiest way to solve it would be to use a using statement instead of declaring it as a separate class:
using Derived = Base<int>;