В чем разница между чертой и политикой?

Я думаю, что вы найдете лучший ответ на свой вопрос в эта книга Андрея Александреску. Здесь я постараюсь дать только краткий обзор. Надеюсь, это поможет.

класс черт это класс, который обычно предназначен для мета-функции, связывающей типы с другими типами или с постоянными значениями, чтобы обеспечить характеристику этих типов. Другими словами, это способ моделирования свойства типов. Механизм обычно использует шаблоны и специализацию шаблонов для определения ассоциации:

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

Метафункция черты my_trait<> выше связывает ссылочный тип T& и постоянное логическое значение false для всех типов T которые не сами ссылки; с другой стороны, он связывает ссылочный тип T& и постоянное логическое значение true для всех типов T тот являются Рекомендации.

Так, например:

int  -> reference_type = int&
isReference = false

int& -> reference_type = int&
isReference = true

В коде мы могли бы утверждать вышеизложенное следующим образом (все четыре строки ниже будут скомпилированы, что означает, что условие, выраженное в первом аргументе для static_assert() доволен)

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

Здесь вы могли видеть, что я использовал стандарт std::is_same<> шаблон, который сам по себе является мета-функцией, которая принимает два, вместо одного введите аргумент. Здесь все может быть сколь угодно сложно.

Хотя std::is_same<> является частью type_traits заголовок, некоторые считают, что шаблон класса является классом черт типа, только если он действует как мета-предикат (таким образом, принимая один параметр шаблона). Однако, насколько мне известно, терминология четко не определена.

Для примера использования класса признаков в стандартной библиотеке C ++ посмотрите, как спроектированы библиотека ввода / вывода и библиотека строк.

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

Например, универсальный класс интеллектуальных указателей может быть спроектирован как шаблонный класс, который принимает политику в качестве параметра шаблона для принятия решения о том, как обрабатывать повторный подсчет — это всего лишь гипотетический, слишком упрощенный и иллюстративный пример, поэтому, пожалуйста, попробуйте абстрагироваться из этого конкретного кода и сосредоточиться на механизм.

Это позволило бы разработчику интеллектуального указателя не делать жестко заданного обязательства относительно того, должны ли модификации счетчика ссылок выполняться поточно-ориентированным образом:

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

В многопоточном контексте клиент может использовать создание шаблона смарт-указателя с политикой, которая реализует поточно-ориентированные приращения и уменьшения счетчика ссылок (предполагается, что Windows Platformmed):

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

Таким образом, разработчик библиотеки предоставил гибкое решение, способное предложить лучший компромисс между производительностью и безопасностью («Вы не платите за то, что не используете»).

Если вы используете ModeT, IsReentrant и IsAsync для управления поведением Сервера, тогда это политика.

В качестве альтернативы, если вы хотите описать характеристики сервера для другого объекта, вы можете определить класс признаков следующим образом:

template <typename ServerType>
class ServerTraits;

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

Вот несколько примеров, поясняющих комментарий Алекса Чемберлена:

Типичным примером класса признаков является std :: iterator_traits. Допустим, у нас есть некоторый шаблонный класс C с функцией-членом, который принимает два итератора, перебирает значения и каким-то образом накапливает результат. Мы хотим, чтобы стратегия накопления также была определена как часть шаблона, но для ее достижения мы будем использовать политику, а не черту.

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

Политика передается в наш шаблонный класс, в то время как признак является производным от параметра шаблона. То, что у вас есть, больше похоже на политику. Есть ситуации, когда черты являются более подходящими, и где политика является более подходящей, и часто тот же самый эффект может быть достигнут с любым из методов, приводящих к некоторой дискуссии, которая является наиболее выразительной.