c++ - 模板化模板特化？

Question

假设我想为 2 个或多个类编写一个包装器，这些类使用不同的实现执行相同的操作，并且它们的接口(interface)具有不同的函数名称。根据上下文，我会选择一个或另一个，但我希望能够轻松地将它们切换出去。所以我写了一个带有模板特化的包装器。好的。但是现在我遇到了一个问题。我的 2 个类是模板类...

如果它们是普通类，我可以编写如下代码:

class A1
{
public:
    int f()
    {
        return 1;
    }
};

class A2
{
public:
    int g()
    {
        return 1;
    }
};


namespace detail
{
    template <class T> int h(T& t)  // general case
    {
        std::cout << "general" << "\n";
        return t.h();
    }
    template <> int h<A1>(A1& a1)     // case for A1
    {
        std::cout << "A1" << "\n";
        return a1.f();
    }
    template <> int h<A2>(A2& a2)     // case for A2
    {
        std::cout << "A2" << "\n";
        return a2.g();
    }
}

template <class T>
class Wrapper
{
public:
    Wrapper(T& t) : t(t) {}

    int operator()()
    {
        return detail::h<T>(t);
    }

    T& t;
};

但是，我需要如何修改该代码才能使其适用于 A1 和 A2 的临时版本？我想到的最好的是这个(不编译):

template <class T>
class A1
{
public:
    int f()
    {
        return 1;
    }
};

template <class T>
class A2
{
public:
    int g()
    {
        return 1;
    }
};


namespace detail
{
    template <class T, class U> int h(T<U>& t)    // general case
    {
        return t.h();
    }
    template <> int h<A1<U>>(A1<U>& a1)     // case for A1
    {
        return a1.f();
    }
    template <> int h<A2<U>>(A2<U>& a1)     // case for A2
    {
        return a1.f();
    }
}

template <class T, class U>
class Wrapper
{
public:
    Wrapper(T<U>& t) : t(t) {}

    int operator()()
    {
        return detail::h<T,U>(t);
    }

    T<U>& t;
};

所以，我不知何故需要对模板特化进行模板化，这听起来很矛盾。

编辑

好吧..试图让过载解决方案起作用，但我真的不明白......

template <template <typename> class T, class  U>
class Wrapper
{
public:
    Wrapper(T<U>& t) : t(t) {}

    template <template <typename> class T, typename U>
    int h(T<U>& t)    // general case
    {
        return t.h();
    }

    template <typename U>
    int h(A1<U>& a1)     // case for A1
    {
        return a1.f();
    }
    template <typename U>
    int h(A2<U>& a2)     // case for A2
    {
        return a2.g();
    }

    T<U>& t;
};

Answer 1

重载优于模板特化:

template <template <typename> class T, typename U>
int h(T<U>& t)    // general case
{
    return t.h();
}

template <typename T>
int h(A1<T>& a1)     // case for A1
{
    return a1.f();
}
template <typename T>
int h(A2<T>& a2)     // case for A2
{
    return a2.g();
}