crtp

Please help me solve this problem. WhiteDragon is to call Dragon::attacks() instead of MonsterImplement::attacks() , and there is ambiguity error here. If I change Dragon to be derived from MonsterImplement, then the line std::cout << monster->numAttacks << std::endl; won't compile because Dragon has no numAttacks data member (nor should it, because different types of Dragons are to have different values). So I need WhiteDragon to call Dragon::attacks() and to call finalizeMonster() during its instantiation. If I make Dragon virtual derived class of Monster, WhiteDragon calls up

Given the following CRTP type in C#: public abstract class DataProviderBase<TProvider> where TProvider : DataProviderBase<TProvider> { } How would I get its generic type definition in F#? let typeDef = typedefof<DataProviderBase<_>> yields the error: Type constraint mismatch when applying the default type 'DataProviderBase<'a>' for a type inference variable. The resulting type would be infinite when unifying ''a' and 'DataProviderBase<'a>' Consider adding further type constraints In C#, it would be: var typeDef = typeof(DataProviderBase<>); UPDATE I found a workaround: [<AbstractClass>] type

I have a composite pattern implementation, used for GUI components: class CObject { private: CObject * m_pParent; CObjectContainer * m_pChildren; void private_foo() { this->foo(); //Calls private_foo for each child in container. m_pChildren->foo(); } public: virtual void foo() { //empty for base class } virtual CObject * duplicate() { //Do duplication code return new CObject(*this); } virtual CObject * detach() { //Remove this object (along with it's children) //from current tree. m_pParent->RemoveChild(this); m_pParent = nullptr; return this; } } class CSpecificObject : public CObject {

I incurred in a compiler dependent issue with the following code (stored in crtp.cc): #include <vector> #include <cassert> #include <iostream> template < class Derived > class AlgebraicVectorExpression { public: typedef std::vector<double>::size_type SizeType; typedef std::vector<double>::value_type ValueType; typedef std::vector<double>::reference ReferenceType; SizeType size() const { return static_cast<const Derived&>(*this).size(); } ValueType operator[](SizeType ii) const { return static_cast<const Derived&>(*this)[ii]; } operator Derived&() { return static_cast<Derived&>(*this); }

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