模板化模板专业化？

Question

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

模板化模板专业化？

templated template specialization?

c++

template-specialization

编辑