Override virtual function through CRTP base class - c++

Question

Old: How can I override a virtual function through a CRTP base class?
struct I { virtual void foo() = 0; };
template<class D>
struct B { void foo() { } }; // provides implementation of foo in D
struct D : I, B<D> { }; // D has an implementation of foo that should override I
int main() { D d; }
Error: unimplemented pure virtual method 'foo' in 'D'
Simpler: How can I override a virtual function without reimplementing it in a derived type? (I guess this question goes against the definition of a virtual function).
struct I { virtual void foo() = 0; };
struct B { void foo() { } };
struct D : B, I { };
int main() { D d; }

Answer 1

Besides the obvious but clunky void foo() { B::foo(); } solution, you could separate the "implements a foo" interface from the more complete interface I:
struct FooInterface {
virtual ~FooInterface() {}
virtual void foo() = 0;
};
struct I : public virtual FooInterface {};
template<class D>
struct B : public virtual FooInterface { void foo() { } };
struct D : I, B<D> {};
int main() { D d; }

Answer 2

You can implement D::foo() as a trivial wrapper calling B<D>::foo(). If you have a lot of places that would need to do this, you could make a macro to help out, like:
#define WRAP(CLASS, METHOD) \
METHOD() { return CLASS::METHOD(); }
struct D : I, B<D>
{
void WRAP(B<D>, foo);
};

Answer 3

you're needlessly mixing two different concepts: crtp, and inheriting an implementation of a virtual function
crtp is used for compile time polyrmorphism, virtual functions for runtime polymorphism
that said, you can inherit in an implementation of a virtual function by way of dominance in a virtual inheritance hierarchy, which yields roughly the effect of java/c# implementation inheritance
example:
struct tutti_i
{
virtual int frutti() const = 0;
};
struct tutti_impl_1
: virtual tutti_i
{
int frutti() const override { return 42; }
};
struct base
: virtual tutti_i
{};
struct derived
: base
, tutti_impl_1
{};
#include <iostream>
int main()
{
tutti_i&& tutti = derived();
std::cout << tutti.frutti() << std::endl;
}

Answer 4

For those who don't care whether or not B inherits from I, you can also implement this with CRTP as originally asked:
struct I { virtual void foo() = 0; };
template <class D>
struct B : I { void foo(){ /* Do something fancy with D's type */ } };
struct D : B<D> { };
And if you need further inheritance so that the implementation of foo is always of the most-derived type, you can introduce an intermediate type to disambiguate which implementation of foo gets used:
struct I { virtual void foo() = 0; };
template <class T>
struct B : virtual I { void foo() { /* Do something fancy with the most-derived type */ }};
struct D : B<D> { };
template <typename Base, typename Derived>
struct InheritFrom : public Base, public B<D> { void foo() { B<D>::foo(); } };
struct FurtherDerived : InheritFrom<D, FurtherDerived> { };