The problem is at stands is that instantiation of nested template requires a complete type of enclosing class and a declaration of template B:
template <typename TChild>
struct Base {
// TChild should be complete at the moment of this declaration
// template B should be declared at this moment.
template <typename T>
using Foo = typename TChild::template B<T>;
};
Instantiation of Base
struct Child : Base<Child>
/* TChild = Child at this moment is incomplete */
{
template <typename T>
using B = T;
/* Point where template B begins to exist */
}; /* point where Child is complete */
Those rules are by design of language, and their goal is to avoid forcing compiler to make multiple passes forth and back through code, possibly in infinite recursion, to actually instantiate what did you mean. Weak-typed interpreter languages often don't have such problem as they can "correct" themselves later.
Case 1.
The static function solution works for the reason that there is no type declaration was done. You had declared a template of function which actually has a global scope, but a concrete function or type aren't created yet.
struct Base {
template <typename T>
static auto constexpr getFoo() {
return typename TChild::template B<T>{};
}
};
struct Child : Base<Child> {
template <typename T>
using B = T;
/* At this point we can instantiate Child::getFoo<int>()*/
}; /* Child is complete now */
At this point instantiation of Child::getFoo<T> is possible but all it requires is the return type of function.
using Bar = decltype(Child::getFoo<int>());
You can place this declaration into Child AFTER the declaration B, because B<int> would be complete at this point. You still can't declare it in Base
Case 2.
Your solution declares another template Foo, it doesn't instantiate it within Base. This template isn't explicitly dependant on TChild but required prototype of foo() to exist at point of instantiation.
template <typename TChild>
struct Base {
template <typename T>
static auto foo(){
return typename TChild::template B<T>();
}
// Foo is a template
template <typename T>
using Foo = std::decay_t<decltype(foo<T>())>;
};
The instantiation happens at point where you would use Base::Foo<T>, which you actually didn't. That declaration is a no-op in your solution. It is legal to use it after the B declaration. You can't use it within Base or anywhere before B was declared.
Now what if you actually need to use an instance of B in Base? Here comes trait class solution:
Case 3.
Traits can be templates specialized for child classes or concrete classes, that's a design choice. A trait serves as a base class for the CRTP base class and is a form of mixin. It's role is to provide useful declarations for CRTP. One of possible solutions for the most flexible trait naming:
template <typename TChild, template<class> typename Trait>
struct Base : public Trait<TChild> {
// Trait<TChild>:: tells compiler that Foo is dependant on TChild
// and is declared in base class Trait. As compiler had reached this
// point, the substitution was successful and thus Trait is complete
using Foo = typename Trait<TChild>::template B<int>;
// Foo is assumed to be a complete type, we can use it here!
Foo make_foo() { return Foo{}; }
};
// Declaring trait template in this case.
template <typename T> struct ChildTrait;
// And specializing
template <>
struct ChildTrait<struct Child> {
template <typename T>
using B = T;
};
struct Child : Base<Child,ChildTrait> {
using Bar = typename Base::Foo;
};
static_assert(std::is_same<Child::B<int>,int>::value,"");
static_assert(std::is_same<Child::B<std::string>,std::string>::value,"");
The idea here is that Trait<TChild> = ChildTrait<Child> has to be and can be a complete class within Base, or we could not derive Base from it. With slight modifications (eliding using, static_assert, typename use) this would compile in C++98 as it doesn't require decltype. This method used by some implementation of standard components, e.g. by std:: streams.
Traits may describe concrete storage types, allocators, etc. WHat's important is that resulting concrete types have no relation but have a shared interface declared in Base.
Basetemplate is instantiated at the moment of deriving some child class from it. If it got a child class of its own, the trait class declared before the concreteBase, that one is a complete class (and will be instantiated before). Using members of Base works only because they aren't types and template parameter is considered a complete type at the moment of instantiation in case of CRTP. One still should be careful and sometimes usethis->to avoid conflicts with global scope. – Barium