奇怪的c++模板方法专业化问题

Question

我在方法专业化方面遇到了一个奇怪的问题。

鉴于此代码...

#include <string>

class X
{
public:

    template< typename T >
    void set( T v );
};

template<>
void X::set( const std::string & v )
{
}

template<>
void X::set( int v )
{
}

int main( int, char *[] )
{
    X x;

    std::string y;

    x.set( y );

    x.set( 1 );
}

当我将其与 g++ 4.3.3 链接时，我得到了一个未定义的引用 void X::set, std::allocator; > >（std::basic_string、std::allocator>）。

这基本上是对 void X::set( std::string ) 的未定义引用。

所以我的问题是，为什么编译器不使用 const std::string & 的专业化？

如果我显式调用 x.set<常量 std::string & >( y ) 然后编译和链接就可以了。

Answer 1

这是完全错误的语法。当专门化模板时，您必须包含尖括号以及您专门化的类型。例如：

template<typename T>
struct X { ... };

template<>
struct X<int> { ... };
//      ^^^^^ see, there have to be angle brackets after the identifier

所以

template<>
void X::set(std::string &) { ... }

不是专门做任何事情，而是实现

class X {
    template<>
    void set(std::string &) { ... }
};

完全不同的功能。我不明白的是为什么 gcc 没有产生错误，因为该类没有该成员。

现在，即使您使用了所谓正确的语法，它也不会是正确的，因为，正如汤姆已经回答的那样，您不能专门化函数（只是用非模板版本重载）。在 C++03 中，即； C++0x 中允许这样做。

Answer 2

编译后恢复到原始命题：

字符串的方法签名不应该是引用。应该是：

template<>
void X::set( const std::string v )
{
}

这是因为在模板定义中您指定了 T paramater 而不是 T&参数

Answer 3

可能是这篇文章
会解释情况。

您可能期望专业化
void X::set( const std::string& ) 将参与重载
解决。
然而，令人惊讶的是，
专业化不参与重载解析。

在调用x.set( y )中，编译器推导主函数中T的类型
来自参数 y 的模板，类型为 std::string。
因此，编译器推断 T 是 std::string，然后搜索匹配的
专业化。

但是，由于 std::string 和 const std::string& 是不同的类型，
编译器最终选择主模板。

选择合适的主模板后，匹配的专业化是
以与类模板的情况相同的方式选择。
未选择专门化 set( const std::string& ) 的原因
类似于专门化 A<; std::string > 未选择
在下面的代码中：

template< class > class A; // primary

template<> class A< const std::string& > {}; // specialization

int main() {
  A< std::string > a; // This doesn't select the specialization
}

Answer 4

你想要使用的是重载。

class X
{
public:
    void set( int v); //the case for ints
    void set( const std::string&) //the case for strings

    //The default catch all case.
    template< typename T >
    void set( T v );
};

//not a template specialisation.
void X::set( int v )
{
}
//not a template specialisation.
void X::set( const std::string & v )
{
}
//the catch all case 
template<typename T>
void X::set(T v)
{
}

非模板运算符将在模板之前选择，因为它们提供更好的匹配（如果可用）。否则将选择模板