C++ 使用模板类型专门化模板方法

给出以下代码段：

struct A {
  template <class T >
  void doSomething(T t) {
    std::cout << "doSomething() with " << t << std::endl;
  }
};
template <class T>
struct B {
  T val;
};

我想达到的目标可能吗？如果是，语法是什么

更新

读了这篇文章，我找到了另一种实现我想要的东西的方法：

由于使用模板时语法并不总是容易，下面是一个具有不同专门化级别的工作示例：

#include <iostream>
#include <vector>

namespace details {
template<class T> struct Impl;
}
struct A {
  template <class T >
  void doSomething(T t) {
    details::Impl<T>::f(t);
  }
};
template <class T>
struct B {
  T val;
};
namespace details {
template<class T>
struct Impl {
  static void f(T t){std::cout << "default" << std::endl;}
};
template<template<class> class U, class T>
struct Impl<U<T> > {
  static void f(U<T> b){std::cout << "default for U<T>"<< std::endl;}
};
template<>
void Impl<double>::f(double d) {
  std::cerr << "doSomething with double " << d << std::endl;
}
template<class T>
struct Impl<B<T> > {
  static void f(B<T> b);
};
template<class T> 
void Impl<B<T> >::f(B<T> b) {
  std::cerr << "doSomething with B<T> " << b.val << std::endl;
}
template<> 
void Impl<B<int> >::f(B<int> b) {
  std::cerr << "doSomething with B<int> " << b.val << std::endl;
}
}
template<class T>
struct C {
  T toto;
};
int main() {
  A a;
  a.doSomething(12.0);
  B<double> b;
  b.val = 42.0;
  a.doSomething(b);
  B<int> b2;
  b2.val = 42.0;
  a.doSomething(b2);
  C<int> c;
  a.doSomething(c);
  std::vector<int> v;
  a.doSomething(v);
  return 0;
}

#包括
#包括
命名空间详细信息{
模板结构Impl；
}
结构A{
模板
无效剂量测定法（T）{
细节：：Impl：：f（t）；
}
};
模板
结构B{
T值；
};
命名空间详细信息{
模板
结构Impl{
静态void f（T T）{std:：cout您不能（部分）专门化它，但可以重载该函数

部分模板专门化仅适用于类。有关示例，请参见gf。您所做的是重载（这是首选方法），但您还必须在类中声明函数
template void doSomething（B）
可能的解决方法：使用带有单个静态成员函数的模板类。
template struct doSomething{static void func（blah）{blah}}
您可以对此类进行部分专门化。所有将函数封装到模板类中的建议都没有考虑到在这种情况下缺少自动模板类型推断。谢谢，但我不能使用自由函数（示例中简化了结构a），这个解决方案强制我在结构中声明两个重载变量。@Charles，是的。那么，你别无选择，只能放弃重载并使用类的部分专门化。
#include <iostream>
#include <vector>

namespace details {
template<class T> struct Impl;
}
struct A {
  template <class T >
  void doSomething(T t) {
    details::Impl<T>::f(t);
  }
};
template <class T>
struct B {
  T val;
};
namespace details {
template<class T>
struct Impl {
  static void f(T t){std::cout << "default" << std::endl;}
};
template<template<class> class U, class T>
struct Impl<U<T> > {
  static void f(U<T> b){std::cout << "default for U<T>"<< std::endl;}
};
template<>
void Impl<double>::f(double d) {
  std::cerr << "doSomething with double " << d << std::endl;
}
template<class T>
struct Impl<B<T> > {
  static void f(B<T> b);
};
template<class T> 
void Impl<B<T> >::f(B<T> b) {
  std::cerr << "doSomething with B<T> " << b.val << std::endl;
}
template<> 
void Impl<B<int> >::f(B<int> b) {
  std::cerr << "doSomething with B<int> " << b.val << std::endl;
}
}
template<class T>
struct C {
  T toto;
};
int main() {
  A a;
  a.doSomething(12.0);
  B<double> b;
  b.val = 42.0;
  a.doSomething(b);
  B<int> b2;
  b2.val = 42.0;
  a.doSomething(b2);
  C<int> c;
  a.doSomething(c);
  std::vector<int> v;
  a.doSomething(v);
  return 0;
}

#include <iostream>

template<class T> struct B { };

template<class T> void doSomething(B<T> t) {  std::cout << "B\n"; }

template <class T> void doSomething(T t) { std::cout << "T\n"; }

int main() {
    int x;
    B<double> k;

    doSomething(x);
    doSomething(k);
}

T
B