C++ 模板专业化问题

我想调用

模板foo（tx）

并手动处理这些情况：

T=std:：vector

，

T=std:：string

，

T=

任何其他情况

以下是我为此写的：

#include <iostream>
#include <vector>
#include <string>

template<typename T> void foo_impl(const std::string &data, std::string *) {
  std::cout << "foo for std::string called\n";
}

template<typename T> void foo_impl(const T &data, T *) {
  std::cout << "foo for general types called\n";
}

template<typename T> void foo_impl(const std::vector<T> &data, std::vector<T> *) {
  std::cout << "foo for std::vector<T> called\n";
}

template<typename T> void foo(const T &data) {
  foo_impl(data, static_cast<T*>(nullptr));
}


int main() {
  int i = 1;
  foo(i);
  std::vector<int> a = {0, 1};
  foo(a);
  std::string s = "abcd";
  foo<std::string>(s);
  return 0;
}

#包括
#包括
#包括
模板void foo_impl（常量std:：string&data，std:：string*）{
std:：cout
T
来自
模板void foo_impl（const std:：string&data，std:：string*）
是不可推断的（也就是说，它不在函数的参数列表中使用），因此，它不被视为可行的重载

您可以删除
模板
部分，并将此重载设置为非模板：

void foo_impl(const std::string &data, std::string *) {
  std::cout << "foo for std::string called\n";
}

template<typename T> void foo(const T &data) {
  std::cout << "foo for general types called\n";
}

void foo_impl（常量std:：string和数据，std:：string*）{
模板的标准：：cout：

template<typename T> void foo(const T &data) {
  std::cout << "foo for general types called\n";
}

另一种方法是转发到可以（部分）专门化的类/结构：

template <typename T>
struct foo_impl {
    void operator (const T&) const
    {
        std::cout << "foo for general types called\n";
    }
};

// specialization for std::string
template <>
struct foo_impl<std::string>
{
    void operator (const T&) const
    {
        std::cout << "foo for std::string called\n";
    }
};

// partial specialization for std::vector
template <typename T, typename A>
struct foo_impl<std::vector<T, A>>
{
    void operator (const std::vector<T, A>&) const
    {
        std::cout << "foo for std::vector<T, A> called\n";
    }
};

template <typename T>
void foo(const T& t)
{
    foo_impl<T>{}(t);
}

模板
结构foo_impl{
无效运算符（常数T&）常数
{
我不清楚为什么要使用两层函数

您可以为
std:：string
和
std:：vector
重载
foo

#包括
#包括
#包括
模板无效foo（常数T和数据）{
std:：我不知道
std:：vector
有多个模板参数。第二个参数的伪指针点是什么？你的类型是从第一个参数推导出来的。@SergeyA是真的吗？std:：vector呢？std:：vector呢？同样的事情。
template<typename T, typename Alloc> void foo(const std::vector<T, Alloc> &data) {
  std::cout << "foo for std::vector<T, Alloc> called\n";
}

template <typename T>
struct foo_impl {
    void operator (const T&) const
    {
        std::cout << "foo for general types called\n";
    }
};

// specialization for std::string
template <>
struct foo_impl<std::string>
{
    void operator (const T&) const
    {
        std::cout << "foo for std::string called\n";
    }
};

// partial specialization for std::vector
template <typename T, typename A>
struct foo_impl<std::vector<T, A>>
{
    void operator (const std::vector<T, A>&) const
    {
        std::cout << "foo for std::vector<T, A> called\n";
    }
};

template <typename T>
void foo(const T& t)
{
    foo_impl<T>{}(t);
}

#include <iostream>
#include <vector>
#include <string>

template<typename T> void foo(const T &data) {
  std::cout << "foo for general types called\n";
}

template <typename T> void foo(const std::vector<T> &data) {
  std::cout << "foo for std::vector<T> called\n";
}

void foo(const std::string &data) {
  std::cout << "foo for std::string called\n";
}

int main() {
  int i = 1;
  foo(i);
  std::vector<int> a = {0, 1};
  foo(a);
  std::string s = "abcd";
  foo(s);
  return 0;
}