使用SFINAE原则时重载函数是不明确的

Question

我遇到了一些用 VS7.1 编写的代码，现在我正在尝试让它适用于 MacOSX。我理解的下面的代码片段是关于SFINAE原则的。据我了解，代码用于在编译时通过依赖某些模板实例化魔术来了解某些内容的类型。简而言之，通过查看模板参数来选择正确的重载。

这是我的代码。稍微简化为仅显示问题。

template <typename T>
struct SomeClass
{
};

template <>
struct SomeClass<char>
{
    typedef char Type;
};

template <typename T>
struct IsChar
{
    typedef char Yes;
    typedef int No;

    template <typename U>
    static Yes Select(U*, typename SomeClass<U>::Type* p = 0);
    template <typename U>
    static No Select(U*, ...);
    static T* MakeT();

    const static bool Value = sizeof(Select(MakeT())) == sizeof(Yes);
};

我只是这样使用它：

if (IsChar<int>::Value)
{
    ...

当编译上面的代码运行良好时，由于使用 int 时缺少 Type 的 typedef，它会选择最顶层的类。

如果我现在使用 char 来代替...

if (IsChar<char>::Value)
{
    ...

...编译器会抱怨不明确的 Select 函数，因为它不知道要使用哪一个。根据我所读到的内容，重载解析最不优先考虑省略号参数（...）。因此，它应该知道选择第一个。

该代码至少在 VS7.1 上运行良好，但在 MacOSX 的 gcc 和 Linux 的 gcc4.4 上运行不佳。

有什么建议如何纠正这个问题吗？也许通常以另一种方式完成？

谢谢！

更新：我意识到我给出的示例代码可能有点过于简化，因为我相信我们不会在这里检查类型，即使我错误地使它看起来像那样。今晚我必须为您收集更多信息，因为我这里没有代码。对此感到抱歉。

UPDATE2：即使我的表现很糟糕，这是由于不熟悉原始代码或以这种方式使用模板。同时我挖掘出更多信息，让我们假设这些构造由于某种原因而存在 X 并且我给出的名称都是错误的，编译器问题怎么办？为什么这里不能选择正确的重载函数？这也让我很感兴趣。正如我所说，我会更好地解释总体目标是什么。

编辑

仔细查看原始代码后，它使用了 boost::integral_constant 和 boost::enable_if ，就像这里建议的那样。问题在于模板参数的推导方式特定，并且它没有按照设置的方式工作。然而，按照格奥尔格在回答最后的建议，我可以纠正一些事情以接受一些事情。我现在有以下内容：

typedef char Yes;
typedef int No;

template <typename U> static Yes Select(typename SomeClass<U>::Type* p);
template <typename U> static No Select(...);

static const bool Value = sizeof(Select<T>(0)) == sizeof(Yes);

这效果很好。在进行一些实验时，我发现 Select 函数中有两个函数参数会导致问题。我还没找到原因当我更好地理解事情时，我会回到这个话题。

感谢您的帮助。至少我现在了解了这里的原理以及事情应该如何运作。只是一些细节，目前还不得而知。

Answer 1

除非我误解了意图，否则上述使用示例不需要使用 SFINAE。如果您只想静态断言 Type 的类型，您可以使用如下内容：

template<class T1, class T2> struct SameType {
    static const bool Value = false;
};

template<class T> struct SameType<T, T> {
    static const bool Value = true;
};

template <typename T>
struct IsChar {
    static const bool Value = SameType<T, char>::Value;
};

如果您确实需要将其用于 SFINAE（即基于模板参数禁用/启用函数），只需使用上面结合类似 Boosts enable_if：

template<class T> 
typename boost::enable_if_c<IsChar<T>::Value, void>::type
someFunction() {
}

或者如果你可以一路Boost：

template<class T> 
typename boost::enable_if<boost::mpl::is_same<T, char>, void>::type
someFunction() {
}

更新：

重读这篇文章，如果你真的想检查 SomeClass 的特化是否有 typedef < code>Type，您应该能够使用 在这里：

template<class T> struct HasType {
    template<class U> static char (&test(typename U::Type const*))[1];
    template<class U> static char (&test(...))[2];
    static const bool Value = (sizeof(test< SomeClass<T> >(0)) == 1);
};

在这种情况下，IsChar 肯定是用词不当，比如 HasType 或HasTypedefType 会更具描述性:)

Answer 2

在我的评论中，我说过您通常不会使用这些谓词的结果作为 if 的值，这就是原因：

// assume we have has_typedef_type from the Wikipedia page:

template <typename T>
void foo(const T& x)
{
    if (has_typedef_type<T>::value)
    {
        // the predicate is true, so T::type exists
        typename T::type y = x;
    }
    else
    {
        // the predicate is false, so T::type doesn't exist, do something else
        float y = x;
    }
}

这可能看起来不错，但请考虑当谓词为 false 时，编译器将尝试编译此代码：

// let's say we called it with double
void foo<double>(const double& x)
{
    if (false)
    {
        // wait, double doesn't have this!
        typename double::type y = x;
    }
    else
    {
        float y = x;
    }
}

问题是代码，即使它会通过死代码删除而被删除，也是格式不正确的。解决方案是让 if 编译时，但首先是一些样板文件：

// in C++0x, these are defined in <type_traits>, but we'll do it ourselves
// (Boost has these as well)
typename <typename T, T Value>
struct integral_constant
{
    typedef T type;
    static const T value = Value;
};

typedef integral_constant<bool, true> true_type;
typedef integral_constant<bool, false> false_type;

有了这些，我们定义我们的函数：

namespace detail
{
    // here are the real implementations
    template <typename T>
    void foo(const T& x, true_type)
    {
        // the predicate is true, so T::type exists
        typename T::type y = x;
    }

    template <typename T>
    void foo(const T& x, false_type)
    {
        // the predicate is false, so T::type doesn't exist, do something else
        float y = x;
    }
}

template <typename T>
void foo(const T& x)
{
    detail::foo(x, // chose which function to call, using the type of this:
                integral_constant<bool, has_typedef_type<T>::value>());
}

现在一切都很好，因为分支是完全独立的来自彼此。