C++ 模板基类子类的模板专门化

这个问题有点难以解释，因此我将从一个示例开始：

我有一个类模板，它将一个类型和一个整型常量作为模板参数，并且我有许多从该模板的实例化派生的子类：

template <class V, int i>
struct Base 
{
    static void doSomething() { cout << "something " << i << endl; };
};

struct Child : public Base<int,12>
{
};

模板
结构基
{
静态void doSomething（）{cout一个简单的解决方案是让
Base
继承另一个
Base\u Base
：

struct Base_base
{};

template <class V, int i>
struct Base
 :  public Base_base
{
    static void doSomething() { cout << "something " << i << endl; };
};

template <class T>
struct Test <T, typename enable_if <is_base_and_derived <Base_base, T>>::type>
{
    static void test (const T &dst)
    {
        dst.doSomething();
    }
};

struct Base\u Base
{};
模板
结构基
：公共基地
{
静态void doSomething（）{cout使用函数重载和
decltype
：

// Never defined:
template<typename T> std::false_type is_Base(T&);
template<class V, int I> std::true_type is_Base(Base<V,I>&);

template<typename IsBase, typename T> struct TestHelper;
template<typename T> struct TestHelper<std::true_type, T>
{
    static void test(const T& dst) { dst.doSomething(); }
};
template<> struct TestHelper<std::false_type, int>
{
    static void test(int dst)
    { std::cout << "Test<int>::test(" << dst << ")" << std::endl; }
};
// ...

template<typename T> struct Test
{
    static void test(const T& dst)
    { TestHelper<decltype(is_Base(std::declval<T&>())), T>::test(dst); }
}

//从未定义：
模板std:：false_类型为_基（T&）；
模板std:：true_类型为_Base（Base&）；
模板结构TestHelper；
模板结构TestHelper
{
静态孔隙试验（常数T&dst）{dst.doSomething（）；}
};
模板结构TestHelper
{
静态孔隙试验（int dst）
{std:：cout感谢Base_Base技巧，这使我当前的代码更具可读性。但是，对于第三方库，这将不起作用，至少如果子类也属于该库的话是不起作用的。@BenjaminSchug:也许在编辑的问题中回答了你的新问题。谢谢，这解释了为什么第一种方法不起作用。看起来像我的gu我的感觉是对的。
template <class V, int i>
struct Base
{
    typedef V VV;
    static constexpr int ii = i;
    static void doSomething() { cout << "something " << i << endl; };
};

template <class T>
struct Test <T, typename enable_if <is_base_and_derived <Base <typename T::VV, T::ii>, T>>::type>
{
    static void test (const T &dst)
    {
        dst.doSomething();
    }
};

struct Base_base
{};

template <class V, int i>
struct Base
 :  public Base_base
{
    static void doSomething() { cout << "something " << i << endl; };
};

template <class T>
struct Test <T, typename enable_if <is_base_and_derived <Base_base, T>>::type>
{
    static void test (const T &dst)
    {
        dst.doSomething();
    }
};

template <class V, int i>
struct Base3rdparty
{
    static void doSomething() { cout << "something " << i << endl; };
};

template <class V, int i>
struct Base
 :  public Base3rdparty<V, i>
{
    typedef V VV;
    static constexpr int ii = i;
};

template <class T>
struct Test <T, typename enable_if <is_base_and_derived <Base <typename T::VV, T::ii>, T>>::type>
{
    static void test (const T &dst)
    {
        dst.doSomething();
    }
};

// Never defined:
template<typename T> std::false_type is_Base(T&);
template<class V, int I> std::true_type is_Base(Base<V,I>&);

template<typename IsBase, typename T> struct TestHelper;
template<typename T> struct TestHelper<std::true_type, T>
{
    static void test(const T& dst) { dst.doSomething(); }
};
template<> struct TestHelper<std::false_type, int>
{
    static void test(int dst)
    { std::cout << "Test<int>::test(" << dst << ")" << std::endl; }
};
// ...

template<typename T> struct Test
{
    static void test(const T& dst)
    { TestHelper<decltype(is_Base(std::declval<T&>())), T>::test(dst); }
}