Как принудительно использовать любопытно повторяющийся шаблон шаблона в C++

Question

У меня есть следующий базовый шаблонный класс.

template<typename T> 
class Base { 
    public: 
    void do_something() { 
    } 
}; 

Он предназначен для использования в качестве с любопытством повторяющегося узора шаблона. Он должен быть унаследован как class B : public Base<B>. Он должен не унаследован как class B : public Base<SomeoneElse>. Я хочу статически применять это требование. Если кто-то использует это неправильно, я ожидаю ошибку на этапе компиляции.

Что я делаю, это положить static_cast<T const&>(*this) в do_something(). Таким образом, класс, наследующий шаблон, наследуется или наследуется от класса, предоставленного в качестве параметра шаблона. Извините за запутанное выражение. На простом английском языке он требует, чтобы B был или наследуется от SomeoneElse в class B : public Base<SomeoneElse>.

Я не знаю, является ли это оптимальным способом достижения этого. Выглядит грубо для меня.

Однако я хочу сделать больше. Я хочу, чтобы B был SomeoneElse сам. Как я могу это сделать?

Answer 1

Сделать конструктор (или деструктор) Base приватным, а затем сделать T a friend. Таким образом, единственное, что может построить/уничтожить Base<T>, - это T.

Answer 2

Если ваш класс содержит код, который говорит:

T* pT = 0; 
Base *pB = pT; 

Тогда будет ошибка компиляции, если T не уступка совместим с Base.

Этот вид проверки оформляется в C++ 11, так что вам не придется писать его вручную и может получить полезные сообщения об ошибках:

#include <type_traits> 

template<typename T> 
class Base { 

public: 
    void do_something() 
    { 
     static_assert(
      std::is_base_of<Base, T>::value, 
      "T must be derived from Base"); 
    } 
}; 

class B : public Base<B> { }; 

int main() 
{ 
    B b; 
    b.do_something(); 
} 

Как обеспечить, чтобы параметр типа Base «s является именно тот класс, который вытекает из него, который кажется концептуально ошибочным. Класс, действующий как базовый класс, не может «говорить» о том, какой тип наследует его. Он может наследоваться несколько раз через множественное наследование или вообще не наследоваться.

Answer 3

Два хороших ответа до сих пор. Вот еще один, который использует идиому генерации пользовательских ключей доступа к определенным методам (в данном случае конструктору). Он обеспечивает абсолютную гарантию правильного использования, не подвергая частные методы в базе производным.

Он также может использоваться для управления доступом к другим методам базового класса в каждом конкретном случае.

template<class Derived> 
struct Base 
{ 
private: 
    // make constructor private 
    Base() = default; 
protected: 
    // This key is protected - so visible only to derived classes 
    class creation_key{ 
     // declare as friend to the derived class 
     friend Derived; 
     // make constructor private - only the Derived may create a key 
     creation_key() = default; 
    }; 

    // allow derived class to construct me with a key 
    Base(creation_key) 
    {} 

    // other methods available to the derived class go here 

private: 
    // the rest of this class is private, even to the derived class 
    // (good encapsulation) 
}; 

struct D1 : Base<D1> 
{ 
    // provide the key 
    D1() 
    : Base<D1>(creation_key()) 
    {} 

};