crtp

So thanks to this answer I'm looking at implementing my problem with CRTP. However I have a problem. In my static base class I have 2 sets of functions. One takes std::vectors and one takes a standard C-style array. So in the base class I define a static function that calls the non-std::vector function. However when I derive from that base class I seem to no longer be able to access the public static function in the base class (Which I thought I could). template< class Derived > class Base { public: static void Func( std::vector< float >& buffer ) { Func( &buffer.front(), buffer.size() ); }

I've got the following code: #include <iostream> #include <cstring> #define THIS(X) static_cast<X*>(this) template<typename T> class Base { public: Base() { } virtual ~Base() { } void foo() { THIS(T)->a[0] = 1; } T& operator=(const T& o) { std::cout <<"operator="<<std::endl; memcpy(THIS(T)->a, o.a, THIS(T)->size); return static_cast<T&>(*this); } }; template<typename T> class Der1: public Base<Der1<T> > { private: T* a; unsigned int size; public: Der1(int d) { a = new T[d]; size = d; } virtual ~Der1() { delete[] a; } using Base<Der1<T> >::operator=; friend class Base<Der1<T> > ; }; template

I have a pretty simple case where I do some basic generic assignment: final Detail detail = field.getAnnotation(Detail.class); final String example = detail.example(); final Class<?> type = field.getType(); if (List.class.isAssignableFrom(type)) ... else if (Enum.class.isAssignableFrom(type)) setValue(contract, field, Enum.valueOf(type, example)); else if (...) ..... but the Enum.valueOf() is a bit difficult to call, in my case, the error is: valueOf(java.lang.Class,java.lang.String) in java.lang.Enum cannot be applied to (java.lang.Class,java.lang.String) This makes perfectly sense since type

Say I have the following code: template <class Derived> class Base { public: virtual void foo_impl() = 0; void foo() { static_cast<Derived*>(this)->foo_impl(); //A (*static_cast<Derived*>(this)).foo_impl(); //B } }; class Derived : public Base<Derived> { private: void foo_impl() { bar(); } }; A few questions: Will line A generate a virtual function call? Although the majority of what I can find on the internet recommends doing things this way, to me I don't see how the compiler can do static dispatch considering that a pointer to Derived could still actually point to an object of type Derived2

Consider the following code: #include <iostream> #include <type_traits> // Abstract base class template<class Crtp> class Base { // Lifecycle public: // MARKER 1 Base(const int x) : _x(x) {} protected: // MARKER 2 ~Base() {} // Functions public: int get() {return _x;} Crtp& set(const int x) {_x = x; return static_cast<Crtp&>(*this);} // Data members protected: int _x; }; // Derived class class Derived : public Base<Derived> { // Lifecycle public: Derived(const int x) : Base<Derived>(x) {} ~Derived() {} }; // Main int main() { Derived d(5); std::cout<<d.set(42).get()<<std::endl; return 0; } If