Как специализировать класс свойств для T, а также для всех потомков T

Для базовых классов:

#include <type_traits>

template<bool b>
using stdbool_t = std::integral_constant<bool, b>;

template<class T, class U = std::true_type>
struct trait
    : std::false_type
{};

struct foo {};
struct bar : foo {};

template<class T>
struct trait<T, stdbool_t<std::is_base_of<foo, T>{}>>
    : std::true_type
{};


#include <iostream>

int main()
{
    std::cout << std::boolalpha;

    std::cout << trait<int>::value << "\n";
    std::cout << trait<foo>::value << "\n";
    std::cout << trait<bar>::value << "\n";
}

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

g++4.8.2 не может скомпилировать этот код (ICE), но он отлично работает с clang+ +3,5

Вот альтернативная версия, которая компилируется на обоих компиляторах:

template<class T, class = void>
struct trait
    : std::false_type
{};

struct foo {};
struct bar : foo {};

template<class T>
struct trait<T, typename std::enable_if<std::is_base_of<foo, T>{}>::type>
    : std::true_type
{};

На самом деле enable_if не нужен. std::conditional тоже подойдет, но здесь enable_if короче.

Если база является специализацией шаблона, мы можем использовать Jarod42 решение (я его немного изменил):

template<template<class...> class T, class U>
struct is_base_template_of
{
private:
    template<class... V>
    static auto test(const T<V...>&)
        -> decltype(static_cast<const T<V...>&>(std::declval<U>()),
                    std::true_type{});

    static std::false_type test(...);

public:
    static constexpr bool value =
        decltype(is_base_template_of::test(std::declval<U>()))::value;
};


template<class T>
struct trait<T,
             typename std::enable_if<is_base_template_of<foo, T>::value>::type>
    : std::true_type
{};

Примечание: это работает только для публичного наследования (и я думаю, что у него есть некоторые дополнительные ограничения: виртуальное и некоторые случаи множественного наследования также не должны работать).

Вот версия трейта того же типа в стиле "C++03 + boost":

template<template<class> class T, class U>
struct is_base_template_of
{
private:
    typedef char false_type;
    typedef char(& true_type)[2];

    template<class V>
    static true_type test(const T<V>*);
    static false_type test(...);

public:
    static const bool value =
       (   sizeof(test(std::declval<typename std::remove_reference<U>::type*>()))
        == sizeof(true_type));
};