Jaka jest różnica między cechą a polisą?

Myślę, że znajdziesz najlepszą możliwą odpowiedź na swoje pytanie w książka Andrei Alexandrescu. Tutaj postaram się dać tylko krótki przegląd. Mam nadzieję, że to pomoże.

A Klasa cech jest klasą, która zazwyczaj ma być meta-funkcją powiązującą typy z innymi typami lub ze stałymi wartościami, aby zapewnić charakterystykę tych typów. Innymi słowy, jest to sposób na modelowanie właściwości typów . Mechanizm zwykle wykorzystuje szablony i specjalizację szablonów do zdefiniowania asocjacji:

template<typename T>
struct my_trait
{
    typedef T& reference_type;
    static const bool isReference = false;
    // ... (possibly more properties here)
};

template<>
struct my_trait<T&>
{
    typedef T& reference_type;
    static const bool isReference = true;
    // ... (possibly more properties here)
};

Metafunkcja cechy my_trait<> powyżej kojarzy Typ odniesienia T& i stałą wartość logiczną false do wszystkich typów T, które są , a nie same w sobie referencjami; z drugiej strony kojarzy Typ odniesienia T& i stałą wartość logiczną true do wszystkich typów T, które są referencjami {28]}.

Więc na przykład:

int  -> reference_type = int&
        isReference = false

int& -> reference_type = int&
        isReference = true

W kodzie możemy twierdzenie to jest następujące (wszystkie cztery linie poniżej skompilują się, co oznacza, że warunek wyrażony w pierwszym argumencie do static_assert() jest spełniony):

static_assert(!(my_trait<int>::isReference), "Error!");
static_assert(  my_trait<int&>::isReference, "Error!");
static_assert(
    std::is_same<typename my_trait<int>::reference_type, int&>::value, 
    "Error!"
     );
static_assert(
    std::is_same<typename my_trait<int&>::reference_type, int&>::value, 
    "Err!"
    );

Tutaj widać, że użyłem standardowego szablonu std::is_same<>, który sam w sobie jest meta-funkcją, która akceptuje dwa , a nie jeden argument typu. Sprawy mogą się tu dowolnie skomplikować.

Chociaż std::is_same<> jest częścią nagłówka type_traits, niektórzy uważają szablon klasy za klasę typu tylko wtedy, gdy działa on jako meta-predykat (w ten sposób akceptując jeden parametr szablonu). Z tego, co wiem, terminologia nie jest jednak jasno określona.

Przykład użycia klasy traits w bibliotece standardowej C++, spójrz na sposób, w jaki zostały zaprojektowane Biblioteki wejścia/wyjścia i biblioteki łańcuchów.

A Polityka jest czymś nieco innym (właściwie całkiem innym). Zwykle ma to być klasa, która określa, jakie zachowanie Inna, generyczna klasa powinna dotyczyć pewnych operacji, które mogą być potencjalnie realizowane na kilka różnych sposobów (a których implementacja jest zatem pozostawiona klasie policy).

Na przykład, OGÓLNA Klasa inteligentnego wskaźnika może być zaprojektowana jako klasa szablonu, która akceptuje politykę jako parametr szablonu do decydowania o tym, jak obsługiwać liczenie ref-jest to tylko hipotetyczny, zbyt uproszczony i ilustracyjny przykład, więc proszę spróbować wyciągnąć z tego konkretnego kod i skup się na mechanizmie .

, które pozwoliłyby projektantowi inteligentnego wskaźnika nie zobowiązywać się do kodowania na twardo, czy modyfikacje licznika odniesienia powinny być wykonywane w sposób bezpieczny dla wątku:

template<typename T, typename P>
class smart_ptr : protected P
{
public:
    // ... 
    smart_ptr(smart_ptr const& sp)
        :
        p(sp.p),
        refcount(sp.refcount)
    {
        P::add_ref(refcount);
    }
    // ...
private:
    T* p;
    int* refcount;
};

W kontekście wielowątkowym klient może użyć instancji szablonu inteligentnego wskaźnika z polityką, która realizuje bezpieczne dla wątku przyrosty i przyrosty licznika referencyjnego (Platforma Windows zakłada tutaj):

class mt_refcount_policy
{
protected:
    add_ref(int* refcount) { ::InterlockedIncrement(refcount); }
    release(int* refcount) { ::InterlockedDecrement(refcount); }
};

template<typename T>
using my_smart_ptr = smart_ptr<T, mt_refcount_policy>;

class st_refcount_policy
{
protected:
    add_ref(int* refcount) { (*refcount)++; }
    release(int* refcount) { (*refcount)--; }
};

template<typename T>
using my_smart_ptr = smart_ptr<T, st_refcount_policy>;

Jeśli używasz ModeT, IsReentrant i IsAsync do kontrolowania zachowania serwera, to jest to Polityka.

Alternatywnie, jeśli chcesz opisać cechy serwera innemu obiektowi, możesz zdefiniować klasę cech w następujący sposób:

template <typename ServerType>
class ServerTraits;

template<>
class ServerTraits<Server>
{
    enum { ModeT = SomeNamespace::MODE_NORMAL };
    static const bool IsReentrant = true;
    static const bool IsAsync = true;
}

Oto kilka przykładów do wyjaśnienia komentarza Alexa Chamberlaina:

Powszechnym przykładem klasy trait jest std:: iterator_traits. Załóżmy, że mamy jakiś szablon klasy C z funkcją member, która pobiera dwa Iteratory, iteruje nad wartościami i gromadzi wynik w jakiś sposób. Chcemy, aby strategia akumulacji również została zdefiniowana jako część szablonu, ale w tym celu wykorzystamy politykę, a nie cechę.

template <typename Iterator, typename AccumulationPolicy>
class C{
    void foo(Iterator begin, Iterator end){
        AccumulationPolicy::Accumulator accumulator;
        for(Iterator i = begin; i != end; ++i){
            std::iterator_traits<Iterator>::value_type value = *i;
            accumulator.add(value);
        }
    }
};

Polityka jest przekazywana do naszego szablonu klasy, natomiast cecha pochodzi z parametru szablonu. Więc to, co masz, jest bardziej podobne do polityki. Są sytuacje, w których cechy są bardziej odpowiednie i gdzie polityki są bardziej odpowiednie, a często ten sam efekt można osiągnąć przy użyciu jednej z metod prowadzących do pewnej debaty, która jest najbardziej wyrazista.