Inheriting member function that returns *this - c++

Question

Why the *this of the derived<T> class is still of base<T> type?
I thought the typename X would take care of that.
If this looks ugly, what is a better way?
Failed Attempt:
template <typename T>
class Derived;
template <typename T, typename X>
class Base{
public:
T val;
X f(void){
return *this;
}
};
template <typename T>
class Derived: public Base<T, Derived<T> >{
};
int main(void){
Derived<int> B;
Derived<int> C = B.f();
}
Error:
test4.cpp(9): error: no suitable user-defined conversion from "Base<int, Derived<int>>" to "Derived<int>" exists
return *this;
^
detected during instantiation of "X Base<T, X>::f() [with T=int, X=Derived<int>]" at line 20
compilation aborted for test4.cpp (code 2)

Answer 1

You may do the downcast with:
X f(){ return static_cast<X&>(*this);}

Answer 2

When the compiler looks at class Base<int, Derived<int>> it has no reason to believe that there is actually a Derived<int> that inherited from it. One could do class Other : public Base<T, Derived<T>>{} and the conversion from class Base<int, Derived<int>> to Derived<int> would be incorrect, so an automatic conversion is not allowed.
If you make a rule that says that the second template parameter must be the derived type that inherits that base (which class Other violates) you can bypass the type system with a cast, but make sure the rule is not violated.

Answer 3

You have
X f(void){
return *this;
}
In this function, type of *this is still the base class type. There is no automatic conversion from the base type to X.
I am unable to suggest a clean solution since X can be anything at that point, not necessarily Derived<T>.
I can use:
template <typename T>
class Derived2 : public Base<T, double>
{
};
How's the base class supposed to deal with that?
The approach used in f() seems to be a design flaw.
Update
If Derived is guaranteed to have the form
template <typename T>
class Derived : public Base<T, Derived<T>>
{
};
Then, you can use:
X& f(void){
return static_cast<X&>(*this);
}
Please note that I changed the return type from X to X&. It avoids the cost of making a copy every time you call the function.

Answer 4

First of all, I would modify Base so that it accepts only one template parameter.
This way, it matches exactly the common form shown for the CRTP idiom.
Actually, it seems to me that there is no reason to use both T and Derived<T> as a template parameter in this case, for the latter already contains the former and T, Derived<T> is the pattern to which you want to adhere:
template<typename>
class Base;
template <typename T, template<typename> typename X>
class Base<X<T>> {
// ...
};
template <typename T>
class Derived: public Base<Derived<T>>{
// ....
};
Then you can use a promotion from the bottom as mentioned by #Jarod42:
X<T> f(void) {
return *static_cast<X<T>*>(this);
}
Note that here you are making systematically a copy of the object and probably it is not what you want.
Another option is to modify a bit the architecture and use a covariant return type (it follows a minimal, working example):
template <typename T>
class Base {
T val;
public:
virtual const Base<T>& f(void) const {
return *this;
}
};
template <typename T>
class Derived: public Base<T> {
public:
virtual const Derived<T>& f(void) const {
return *this;
}
};
int main(void) {
Derived<int> B;
Derived<int> C = B.f();
}
Which one is better for you mostly depends on the actual problem.