(1) The topmost class in the hierarchy looks like: template <typename T> class A { public: void bar() const { // do something and then call foo (possibly) in the derived class: foo(); } void foo() const { static_cast<const T*>(this)->foo(); } protected: ~A() = default; // Constructors should be protected as well. }; A<T>::foo() behaves … Read more
It’s not a problem at all and is solved with one line in derived class: friend class Base< Derived >; #include <iostream> template< typename PDerived > class TBase { public: void Foo( void ) { static_cast< PDerived* > ( this )->Bar(); } }; class TDerived : public TBase< TDerived > { friend class TBase< TDerived … Read more
Your guess is correct. A deduced return type is not actually deduced until the signature of the function is needed. This means that it will be deduced in the context of the call to getCallOperator, at which point Foo is fully defined. This is specified in 7.1.6.4p12: Return type deduction for a function template with … Read more
The assignment operator is technically inherited; however, it is always hidden by an explicitly or implicitly defined assignment operator for the derived class (see comments below). (13.5.3 Assignment) An assignment operator shall be implemented by a non-static member function with exactly one parameter. Because a copy assignment operator operator= is implicitly declared for a a … Read more
Simulated dynamic binding. Avoiding the cost of virtual function calls while retaining some of the hierarchical benefits is an enormous win for the subsystems where it can be done in the project I am currently working on.
The reason is that when instantiating a class template, all its declarations (not the definitions) of its member functions are instantiated too. The class template is instantiated precisely when the full definition of a specialization is required. That is the case when it is used as a base class for example, as in your case. … Read more
derived is incomplete when you use it as a template argument to base in its base classes list. A common workaround is to use a traits class template. Here’s your example, traitsified. This shows how you can use both types and functions from the derived class through the traits. // Declare a base_traits traits class … Read more
There are two ways. The first one is by specifying the interface statically for the structure of types: template <class Derived> struct base { void foo() { static_cast<Derived *>(this)->foo(); }; }; struct my_type : base<my_type> { void foo(); // required to compile. }; struct your_type : base<your_type> { void foo(); // required to compile. }; … Read more
It means that the type argument for enum has to derive from an enum which itself has the same type argument. How can this happen? By making the type argument the new type itself. So if I’ve got an enum called StatusCode, it would be equivalent to: public class StatusCode extends Enum<StatusCode> Now if you … Read more
In short, CRTP is when a class A has a base class which is a template specialization for the class A itself. E.g. template <class T> class X{…}; class A : public X<A> {…}; It is curiously recurring, isn’t it? 🙂 Now, what does this give you? This actually gives the X template the ability … Read more