Two different mixin patterns in C++. (mixin? CRTP?)

Question

I'm studying about mixins (in C++). I read some articles on mixins and found two different patterns of "approximating" mixins in C++.

Pattern 1:

template<class Base>
struct Mixin1 : public Base {
};

template<class Base>
struct Mixin2 : public Base {
};

struct MyType {
};

typedef Mixin2<Mixin1<MyType>> MyTypeWithMixins;

Pattern 2: (may be called CRTP)

template<class T>
struct Mixin1 {
};

template<class T>
struct Mixin2 {
};

struct MyType {
};

struct MyTypeWithMixins : 
    public MyType, 
    public Mixin1<MyTypeWithMixins>, 
    public Mixin2<MyTypeWithMixins> {
};

Are they equivalent practically? I'd like to know practical difference between the patterns.

Answer 1

The difference is visibility. In the first pattern, MyType's members are directly visible to and usable by the mixins, without any need for casting, and Mixin1's members are visible to Mixin2. If MyType wants to access members from the mixins, it needs to cast this, and there isn't a great way to do so safely.

In the second pattern, there is no automatic visibility between the type and the mixins, but the mixins can safely and easily cast this to MyTypeWithMixins and thereby access the members of the type and of other mixins. (MyType could too, if you applied the CRTP to it too.)

So it comes down to convenience versus flexibility. If your mixins are purely accessing services from the type, and have no sibling dependencies of their own, the first pattern is nice and straightforward. If a mixin depends on services provided by the type or other mixins, you're more or less forced to use the second pattern.