C++ 如何专门化模板函数，使其接受将字符数组作为参数传递？ //problem.cpp: #包括 模板无效函数（常数T&v）； int main（）{ int i； 浮动f； char*cp； char-ca[4]； func（i）； func（f）； func（cp）； func（std:：string（“std:：string”）； func（ca）； func（“字符串文字”）； 返回0； } //问题2.cpp #包括 模板无效函数（常数T&v）； //对“void func（int const&）”的未定义引用 模板void func（const int&v）{} //对“void func（float const&）”的未定义引用 模板void func（常量float&v）{} //对“void func（char*const&）”的未定义引用 模板void func（char*const&v）{} //void func（标准：：基本字符串常量&） 模板void func（std:：string const&v）{} //对“void func（char const（&）[4]）的未定义引用 // ??? //对“void func（char const（&）[15]）的未定义引用 // ???

找到了两种解决方案：

a） 在problem2.cpp中：

// problem.cpp:
#include <string>

template<typename T> void func(const T & v);

int main() {
        int i;
        float f;
        char * cp;
        char ca[4];

        func(i);
        func(f);
        func(cp);
        func(std::string("std::string"));
        func(ca);
        func("string_literal");

        return 0;
}

// problem2.cpp
#include <string>

template<typename T> void func(const T & v);

// undefined reference to `void func<int>(int const&)'
template<> void func<int>(const int & v) { }

// undefined reference to `void func<float>(float const&)'
template<> void func<float>(const float & v) { }

// undefined reference to `void func<char*>(char* const&)'
template<> void func<char *>(char * const & v) { }

// void func<std::basic_string<char, std::char_traits<char>, std::allocator<char> > >(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)
template<> void func<std::string>(std::string const & v) { }

// undefined reference to `void func<char [4]>(char const (&) [4])'
// ???

// undefined reference to `void func<char [15]>(char const (&) [15])'
// ???

template void func（const char（&v）[4]）{
模板void func（const char&v）[15]）{}

b） 在problem.cpp中：

template<> void func<char[4]>(const char (&v)[4]) { }
template<> void func<char[15]>(const char (&v)[15]) { }

template void func（常数T（&v）[N]）{func（v+0）；}
然后在problem2.cpp中，添加新缺少的
模板void func（const char*const&v）{}

抱歉，阿卡帕，不得不再次编辑以澄清它们是两个独立的解决方案

---

阿卡帕：我唯一能为这个问题添加内容的方法就是编辑它。我既不能评论也不能添加答案。可能与»堆栈溢出需要来自另一个域的外部JavaScript，该域被阻止或加载失败。«我不知道如何解决，因为我不知道这一点，所以SO试图告诉我。

函数专门化很棘手，因为它们必须与参数的类型完全匹配。对于数组（字符串文字也是数组），编译器将执行类型推断并找出确切的类型，然后在程序中查找特定符号

特别是，

ca

的类型是

char[4]

，因此在调用模板时，推导出的类型是

T==char[4]

，它希望找到的函数签名是

void func（const char（&[4]）

对于您的两种解决方案，它们是完全不同的方法。在第一种情况下，您将为所使用的特定类型专门化模板。这将变得很痛苦，因为对于您使用的每个新字符串文本大小或类型，您将需要手动添加专门化。顺便说一句，这就是为什么模板应该（经常）在头中定义的原因，这样您就不需要在显式实例化（*）中命名所有可能的模板参数

第二种解决方案完全不同。在本例中，您正在创建第二个不相关（在某种程度上）的基础模板。该基础模板获取指向数组第一个元素的指针，并使用该指针调用原始模板，从而有效地更改类型（并在过程中丢失信息：大小现在丢失）。此时，所有带有数组的调用都将与第二个模板匹配，并作为调用转发给带有指针的原始模板，从而减少了对数组大小进行专门化的需要（编译器将解决这些专门化）

还要注意，如果您只想允许传递字符数组，则dispatcher模板不需要接受所有类型，它可以有一个非类型参数：

template<typename T, unsigned N> void func(const T (&v)[N]) { func(v+0); }
and then in problem2.cpp, add the newly missing
template<> void func<const char *>(const char * const & v) { }

模板
void f（const char（&a）[N]）{f（&a[0]）；}

总结：

避免函数的模板专门化，因为处理这些函数很麻烦。数组的类型包括大小，这反过来意味着您需要专门处理每个可能的数组大小。或者，您可以添加将分派到原始模板的辅助模板，执行到指针的转换

---

*请注意，如果每个专门化和所有专门化的实现都相同，则可以避免专门化（和复制代码），同时通过在.cpp中提供模板的定义，然后手动实例化模板来保持相同的行为：

template <std::size_t N>
void f( const char (&a)[N] ) { f( &a[0] ); }

模板无效函数（T常量&）{
//代码在这里
}
模板无效函数（int const&）；
模板无效函数（双常量&）；
//...

不要专门化函数模板。真的，不要。@akappa:没错--@Xeo:我确实删除了我的评论，因为这是我在谷歌上通过简单搜索得到的第一个链接；）@user1468595:将解决方案放入一个答案中并接受它：对于那些在这里为您的同一问题寻找答案的错误用户来说，它更好。@akappa:您甚至可以使用重载解析来完成，所以是的，我个人觉得它真的没用（除非您需要它来扩展一个已建立的接口或其他东西）（就像早期的

std:：swap

建议），但即使这样，ADL的效果也要好得多，因为您不能部分地专门化函数模板）。

template <typename T> void func( T const & ) {
   // code goes here
}
template void func<int>( int const & );
template void func<double>( double const & );
//...