SFINAE 编译器问题

Question

我的以下代码应该检测 T 是否有 begin 和 end 方法：

template <typename T>
struct is_container
{
    template <typename U, typename U::const_iterator (U::*)() const,
                          typename U::const_iterator (U::*)() const>
    struct sfinae {};

    template <typename U> static char test(sfinae<U, &U::begin, &U::end>*);
    template <typename U> static long test(...);

    enum { value = (1 == sizeof test<T>(0)) };
};

这里是一些测试代码：

#include <iostream>
#include <vector>
#include <list>
#include <set>
#include <map>

int main()
{
    std::cout << is_container<std::vector<std::string> >::value << ' ';
    std::cout << is_container<std::list<std::string> >::value << ' ';
    std::cout << is_container<std::set<std::string> >::value << ' ';
    std::cout << is_container<std::map<std::string, std::string> >::value << '\n';
}

在 g++ 4.5.1 上，输出为1 1 1 1。然而，在 Visual Studio 2008 上，输出为 1 1 0 0。是我做错了什么，还是这只是 VS 2008 的一个 bug？任何人都可以在不同的编译器上进行测试吗？谢谢！

Answer 1

所以，这就是我如何调试这些东西。

首先，注释掉否定的替代方案，这样您就会得到错误而不仅仅是不匹配。
接下来，尝试使用不起作用的项目之一实例化您在函数中放入的类型。

在此步骤中，我能够实例化您的 sfinae 对象，但它仍然无法正常工作。 “这让我知道这是 VS 的一个 bug，所以接下来的问题是如何修复它。” -- OBS

当按照你的方式完成时，VS 似乎在 SFINAE 方面遇到了麻烦。 当然可以！当您包装 sfinae 对象时效果会更好。我这样做了：

template <typename U, typename it_t = typename U::const_iterator >
struct sfinae 
{
  // typedef typename U::const_iterator it_t; - fails to compile with non-cont types.  Not sfinae
  template < typename U, typename IT, IT (U::*)() const, IT (U::*)() const >
  struct type_ {};

  typedef type_<U,it_t,&U::begin,&U::end> type;
};

仍然无法正常工作，但至少我收到了一条有用的错误消息：

error C2440: 'specialization' :无法从 'overloaded-function' 转换为 'std::_Tree_const_iterator<_Mytree>; (__thiscall std::set<_Kty>::* )(void) const'

这让我知道 &U::end 对于 VS 来说是不够的 (< em>任何编译器）能够告诉我想要哪个 end()。 static_cast 修复了这个问题：

  typedef type_<U,it_t,static_cast<it_t (U::*)() const>(&U::begin),static_cast<it_t (U::*)() const>(&U::end)> type;

将它们全部放回一起，然后在其上运行您的测试程序...在 VS2010 中成功。您可能会发现 static_cast 实际上就是您所需要的，但我将其留给您来查找。

我想现在真正的问题是，哪个编译器是正确的？我的赌注是一致的：g++。 指点智者：永远不要假设我当时做了什么。

编辑：天哪... 你错了！

更正版本：

template <typename T>
struct is_container
{
    template <typename U, typename it_t = typename U::const_iterator > 
    struct sfinae 
    {
      //typedef typename U::const_iterator it_t;
      template < typename U, typename IT, IT (U::*)() const, IT (U::*)() const >
      struct type_ {};

      typedef type_<U,it_t,static_cast<it_t (U::*)() const>(&U::begin),static_cast<it_t (U::*)() const>(&U::end)> type;
    };

    template <typename U> static char test(typename sfinae<U>::type*);
    template <typename U> static long test(...);

    enum { value = (1 == sizeof test<T>(0)) };
};



#include <iostream>
#include <vector>
#include <list>
#include <set>
#include <map>

int main()
{
    std::cout << is_container<std::vector<std::string> >::value << ' ';
    std::cout << is_container<std::list<std::string> >::value << ' ';
    std::cout << is_container<std::set<std::string> >::value << ' ';
    std::cout << is_container<std::map<std::string, std::string> >::value << ' ';
    std::cout << is_container<bool>::value << '\n';
}

--
上面的调试是合理的，但是关于编译器的假设是错误的。由于我上面强调的原因，G++ 应该会失败。

Answer 2

你为什么要付出这么多努力？如果您想检查 U::begin() 是否存在，为什么不尝试一下呢？

template <typename T>
struct is_container
{
    template <typename U> static char test(U* u,
       typename U::const_iterator b = ((U*)0)->begin(),
       typename U::const_iterator e = ((U*)0)->end());
    template <typename U> static long test(...);

    enum { value = (1 == sizeof test<T>(0)) };
};

除了检查 U::begin() 和 U::end() 是否存在之外，还检查它们是否返回可转换为 的内容>const_iterator。它还通过使用必须支持的调用表达式而不是假设特定的签名来避免 Stephan T. Lavavej 强调的陷阱。

[编辑]
抱歉，这依赖于VC10的模板实例化。更好的方法（将存在性检查放入参数类型中，确实参与重载）：

template <typename T> struct is_container
{
    // Is.
    template <typename U>
    static char test(U* u, 
                     int (*b)[sizeof(typename U::const_iterator()==((U*)0)->begin())] = 0,
                     int (*e)[sizeof(typename U::const_iterator()==((U*)0)->end())] = 0);
    // Is not.
    template <typename U> static long test(...);

    enum { value = (1 == sizeof test<T>(0)) };
};

Answer 3

使用 C++11，现在有更好的方法来检测这一点。我们不依赖函数的签名，而是简单地在表达式 SFINAE 上下文中调用它们：

#include <type_traits> // declval

template<class T>
class is_container{
  typedef char (&two)[2];

  template<class U> // non-const
  static auto test(typename U::iterator*, int)
      -> decltype(std::declval<U>().begin(), char());

  template<class U> // const
  static auto test(typename U::const_iterator*, long)
      -> decltype(std::declval<U const>().begin(), char());

  template<class>
  static two  test(...);

public:
  static bool const value = sizeof(test<T>(0, 0)) == 1;
};

Ideone 上的实时示例。 int 和 long 参数仅在容器同时提供两者时消除重载解析的歧义（或者如果 iterator 是 typedef const_iterator iterator，就像允许 std::set 一样） - 文字 0 是 int 类型，并强制选择第一个重载。

Answer 4

Stephan T. Lavavej 有 this 表示：

请注意，从技术上讲，禁止获取标准库成员函数的地址。（它们可以重载，从而使 &foo::bar 不明确，并且它们可以有额外的默认参数，从而阻止通过 static_cast 消除歧义的尝试。）

所以我想我将使用仅检查嵌套 const_iterator 类型的更简单版本。

Answer 5

这可能应该是一条评论，但我没有足够的点

@MSalters

即使​​你的 is_container 工作（几乎）并且我自己使用了你的代码，我发现了其中的两个问题。

首先，类型 deque::iterator 被检测为容器（在 gcc-4.7 中）。看起来 deque::iterator 定义了 begin/end 成员和 const_iterator 类型。

第二个问题是，根据 GCC 开发人员的说法，该代码无效。我引用：默认参数的值不是函数类型的一部分，不参与推导。请参阅 GCC bug 51989

我目前正在使用 this（仅限 C++11）对于 is_container：

template <typename T>
struct is_container {
    template <
        typename U,
        typename S = decltype (((U*)0)->size()),
        typename I = typename U::const_iterator
    >
    static char test(U* u);
    template <typename U> static long test(...);
    enum { value = sizeof test<T>(0) == 1 };
};