¿Cuál es la diferencia entre un rasgo y una política?

Creo que encontrará la mejor respuesta posible a su pregunta en este libro de Andrei Alexandrescu. Aquí, trataré de dar un breve resumen. Espero que ayude.

Una clase de rasgos es una clase que generalmente pretende ser una meta-función que asocia tipos a otros tipos o a valores constantes para proporcionar una caracterización de esos tipos. En otras palabras, es una forma de modelar propiedades de los tipos. Mecanismo normalmente explota las plantillas y la especialización de plantillas para definir la asociación:

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

La metafunción de rasgo my_trait<> anterior asocia el tipo de referencia T& y el valor booleano constante false a todos los tipos T que son no referencias; por otro lado, asocia el tipo de referencia T& y el valor booleano constante true a todos los tipos T que son referencias.

Así que por ejemplo:

int  -> reference_type = int&
        isReference = false

int& -> reference_type = int&
        isReference = true

En código, podríamos haga valer lo anterior de la siguiente manera (las cuatro líneas a continuación se compilarán, lo que significa que la condición expresada en el primer argumento de static_assert() se cumple):

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!"
    );

Aquí se puede ver que hice uso de la plantilla estándar std::is_same<>, que es en sí misma una meta-función que acepta dos, en lugar de uno, argumento de tipo. Las cosas pueden complicarse arbitrariamente aquí.

Aunque std::is_same<> es parte del encabezado type_traits, algunos consideran que una plantilla de clase es una clase de rasgos de tipo solo si actúa como un meta-predicado (por lo tanto, aceptando un parámetro de plantilla). Sin embargo, a mi leal saber y entender, la terminología no está claramente definida.

Para ver un ejemplo de uso de una clase traits en la Biblioteca Estándar de C++, eche un vistazo a cómo están diseñadas la Biblioteca de Entrada/Salida y la Biblioteca de Cadenas.

Una política es algo ligeramente diferente (en realidad, bastante diferente). Normalmente está destinado a ser una clase que especifica lo que el comportamiento de otra clase genérica debe referirse a ciertas operaciones que podrían realizarse potencialmente de varias maneras diferentes (y cuya implementación, por lo tanto, se deja en manos de la clase policy).

Por ejemplo, una clase genérica de puntero inteligente podría diseñarse como una clase de plantilla que acepta una política como un parámetro de plantilla para decidir cómo manejar el recuento de referencias, esto es solo un ejemplo hipotético, excesivamente simplista e ilustrativo, así que intente abstraerse de este concreto codificar y centrarse en el mecanismo .

Eso permitiría al diseñador del puntero inteligente no hacer ningún compromiso codificado en cuanto a si las modificaciones del contador de referencia se realizarán de manera segura para subprocesos:

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;
};

En un contexto de subprocesos múltiples, un cliente podría usar una instanciación de la plantilla de puntero inteligente con una política que realiza incrementos y decrementos seguros para subprocesos del contador de referencia (se asume que Windows platformed aquí):

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>;

En un entorno de subproceso único, por otro lado, un cliente podría instanciar la plantilla de puntero inteligente con una clase de política que simplemente aumenta y disminuye el valor del contador:

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>;

De esta manera, el diseñador de bibliotecas ha proporcionado una solución flexible que es capaz de ofrecer el mejor compromiso entre rendimiento y seguridad ("No pagas por lo que no usas").

Si está utilizando ModeT, IsReentrant e IsAsync para controlar el comportamiento del servidor, entonces es una política.

Alternativamente, si desea una forma de describir las características del servidor a otro objeto, entonces podría definir una clase traits como esta:

template <typename ServerType>
class ServerTraits;

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

Aquí hay un par de ejemplos para aclarar el comentario de Alex Chamberlain:

Un ejemplo común de clase trait es std::iterator_traits. Digamos que tenemos una plantilla clase C con una función miembro que toma dos iteradores, itera sobre los valores y acumula el resultado de alguna manera. Queremos que la estrategia de acumulación se defina también como parte de la plantilla, pero usaremos una política en lugar de un rasgo para lograrlo.

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

La política se pasa a nuestra plantilla clase, mientras que el rasgo se deriva del parámetro template. Así que lo que tienes es más parecido a una política. Hay situaciones donde los rasgos son más apropiados, y donde las políticas son más apropiadas, y a menudo el mismo efecto se puede lograr con cualquiera de los métodos que conducen a un debate sobre cuál es el más expresivo.