Jak wymusić użycie ciekawie powtarzającego się wzorca szablonu w C++

Question

Mam następującą klasę podstawowego szablonu.

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

jest przeznaczony do stosowania jako co ciekawe powtarzające się szablon wzoru. Powinien być dziedziczony jak class B : public Base<B>. Musi być , a nie odziedziczony jak class B : public Base<SomeoneElse>. Chcę statycznie egzekwować ten wymóg. Jeśli ktoś użyje tego błędu, oczekuję błędu w fazie kompilacji.

Co robię, umieszczam static_cast<T const&>(*this) w do_something(). W ten sposób klasa dziedzicząca szablon jest dziedziczona z klasy podanej jako parametr szablonu. Przepraszamy za mylące wyrażenie. W prostym angielskim wymaga B lub dziedziczy po SomeoneElse w class B : public Base<SomeoneElse>.

Nie wiem, czy jest to optymalny sposób, aby to osiągnąć. Wygląda obrzydliwie dla mnie.

Jednak chcę zrobić więcej. Chcę się upewnić, że B jest sam. Jak mogę to zrobić?

Answer 1

Utwórz konstruktor (lub destruktor) z Base jako prywatny, a następnie zmień T na friend. W ten sposób jedyną rzeczą, która może skonstruować/zniszczyć Base<T> jest T.

Answer 2

Jeśli klasa zawiera jakiś kod, który mówi:

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

Wtedy nie będzie to błąd kompilatora, jeśli nie jest przyporządkowanie T kompatybilne z Base.

Ten rodzaj czeku jest sformalizowana w C++ 11, dzięki czemu nie trzeba pisać ręcznie i może się pomocne komunikaty o błędach:

#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(); 
} 

chodzi o zapewnienie, że parametr typu Base „s jest dokładnie klasa wywodząca się z tego, co wydaje się błędne koncepcyjnie. Klasa, która działa jako klasa podstawowa, nie może "mówić" o typie, który ją dziedziczy. Może być dziedziczony więcej niż jeden raz przez wielokrotne dziedziczenie lub wcale.

Answer 3

Dwie dobre odpowiedzi do tej pory. Tutaj jest inny, który używa idiomu generowania niestandardowych kluczy dostępu do niektórych metod (w tym przypadku konstruktora). Zapewnia absolutną gwarancję prawidłowego użytkowania, nie narażając prywatnych metod w bazie na pochodne.

Może być również używany do kontrolowania dostępu do innych metod w klasie bazowej dla każdego przypadku z osobna.

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()) 
    {} 

};