C++与枚举匹配的模板函数中无法解释的变化

Question

我有以下包含模板函数的代码。当我使用第二个参数作为枚举来调用此函数时：在某些情况下，它会找到模板专业化，而在某些情况下则不会。

我已经验证枚举在两种情况下都是相同的枚举（例如没有重新定义）并且其他参数具有正确的值，我发现一个编译是使用 -Winline set 完成的（我还没有尝试更改它）还有什么看看？

class A {
public:
    template <typename T>
    int f(uint32_t id, T const& t, bool cond);

    ...
};

template <typename T>
int A::f(uint32_t id, T const& t, bool cond)
{
   ...
}

template <>
inline int A::f<int>(uint32_t, int const& t, bool cond)
{
   ....
}

Answer 1

对于初学者来说，通常不建议使用模板专门化作为重载模板函数的方式。模板特化与函数重载的交互很差，并且有一些相当晦涩的规则来规定何时选择它们，并且通常认为仅提供常规函数重载比专门化函数模板更好。

在这种情况下，我建议将您的类更改为如下所示：

class A {
public:
    template <typename T>
        int f(uint32_t id, T const& t, bool cond);
    int f(uint32_t id, int t, bool cond);
    ...
};

然后将模板专业化更改为重载的实现。由于 C++ 函数重载的工作方式，这将更准确地选择函数的正确版本。

至于您的特定问题，您的代码并不总是调用重载的原因是 C++ 对枚举类型和 int 类型进行了区分。尽管有多种方法可以在 int 和枚举类型之间进行转换，但它们并不是同一回事，并且设计用于捕获 int 的重载并不能保证捕获枚举类型以及。您最好专门重载该函数来处理枚举的情况。

Answer 2

不是尝试的答案，但想要发布的内容超出了评论的范围...

基本上，这显示了 GCC 3.4.6 的预期行为（枚举从不匹配 int 专业化）。你使用什么编译器？你真的能提供一个类似的、完整的程序来产生错误吗？

#include <iostream>                                                             

struct A                                                                        
{                                                                               
  public:                                                                       
    template <typename T>                                                       
    void f(const T&) { std::cout << "general\n"; }                              
};                                                                              

template <>                                                                     
void A::f<int>(const int&) { std::cout << "specialised\n"; }                    

enum E1 { Zero, One, Two };                                                     

enum E2 { Max = INT_MAX };                                                      

int main()                                                                      
{                                                                               
    A a;                                                                        
    a.f("abc");                                                                 
    a.f(123);                                                                   
    a.f(Zero);                                                                  
    E1 e = Two;                                                                 
    a.f(e);                                                                     
    a.f(Max);                                                                   
}

输出：

general
specialised
general
general
general