Question

您好，对不起我的英语不好。

为了练习c ++ 11，我正在尝试编写std :: experimental :: any（http://en.cppreference.com/w/cpp/experimental/any）类的一个版本，增加了额外的东西。

添加运算符＆lt;（）我在g ++（4.9.2）和clang ++（3.5.0）之间有不同的行为。

以下是该类（和使用的类）的缩短版本，涵盖了必要的最小值，以及一个非常小的main（）来触发问题。

对于长代码很抱歉，但我没有将示例缩短。

#include <memory>
#include <iostream>
#include <type_traits>
#include <unordered_set>

namespace yans // yet another name space
 {
   class anyB  // base for any
    {
      public:

         virtual std::type_info const & typeT () const = 0;
         virtual bool isLess (anyB const *) const = 0;
    };

   template <typename T>
      class anyD : public anyB  // derived for any
       {
         private:

            T val;

            static std::type_info const & typeInfo ()
             { static auto const & ret = typeid(T); return ret; }

            template <typename U> // preferred version
               static auto lessF (U const & u1, U const & u2, int)
               -> decltype(  std::declval<U const &>()
                           < std::declval<U const &>())
                { return (u1 < u2); }

            template <typename U> // emergency version
               static auto lessF (U const &, U const &, ...) -> bool
                { throw std::runtime_error("no operator < for type "); }

         public:

            anyD (T const & v0)
               : val(v0)
                { }

            std::type_info const & typeT () const override final
             { return typeInfo(); }

            bool isLess (anyB const * pB0) const override final
             {
               auto pD0 = dynamic_cast<anyD<T> const *>(pB0);

               if ( nullptr == pD0 )
                  throw std::bad_cast();

               return lessF(val, pD0->val, 0);
             }
       };

   class any
    {
      private:
         template <class T>
            using sT = typename std::decay<T>::type;

         template <class T>
            using noAny
            = typename std::enable_if
            <false == std::is_same<any, sT<T>>::value, bool>::type;

         template <class T>
            using isCpCtr
            = typename std::enable_if
            <true == std::is_copy_constructible<sT<T>>::value,bool>::type;

         std::unique_ptr<anyB>  ptr;

         static std::type_info const & voidInfo ()
          { static auto const & ret = typeid(void); return ret; }

         bool opLess (any const & a0) const
          {
            return
                  type().before(a0.type())
               || (   (type() == a0.type())
                   && (false == empty())
                   && ptr.get()->isLess(a0.ptr.get()) );
          }

      public:

         template <typename T, typename = noAny<T>, typename = isCpCtr<T>>
            any (T && v0)
            : ptr(new anyD<sT<T>>(std::forward<T>(v0)))
             { }

         bool empty () const noexcept
          { return ! bool(ptr); }

         std::type_info const & type () const
          { return ( ptr ? ptr->typeT() : voidInfo()); }

         friend bool operator< (any const &, any const &);
    };

   bool operator< (any const & a0, any const & a1)
    { return a0.opLess(a1); }
 }

int main () 
 {
   try
    {
      yans::any  ai { 12 };
      yans::any  as { std::string("t1") };
      yans::any  au { std::unordered_set<int> { 1, 5, 3 } };

      std::cout << "ai < 13 ? " << (ai < 13) << '\n';
      std::cout << "as < std::string {\"t0\"} ? "
         << (as < std::string {"t0"}) << '\n';
      std::cout << "au < std::unordered_set<int> { 2, 3, 4 } ? "
         << (au < std::unordered_set<int> { 2, 3, 4 }) << '\n';
    }
   catch ( std::exception const & e )
    {
      std::cerr << "\nmain(): standard exception of type \""
         << typeid(e).name() <<"\"\n"
         << "  ---> " << e.what() << " <---\n\n";
    }

   return EXIT_SUCCESS;
 }

运算符＆lt;（）后面的想法是，如果左操作数的类型小于右类型（根据typeid（T）.before（）），则返回“true”，如果类型匹配，返回包含值的比较返回的值。我知道这是一个值得怀疑的解决方案，但我正在努力学习。

问题在于，在类的实例中，任何类型的值都可以包含没有运算符＆lt;（）的类型。在示例中，类std :: unordered_set＆lt; int＆gt;的实例。然后我尝试开发一些重载（SFINAE）方法lessF（）;当运算符＆lt;（）可用于包含的类型T时，首选的一个返回比较值;当运算符＆lt;（）不可用时使用的紧急版本会抛出异常。

使用clang ++，我得到了我想要的东西：类anyD＆lt; std :: unordered_set＆lt; int＆gt;＆gt;没有实现lessF的首选版本，比较会从紧急版本中生成异常。

使用g ++，相反，类anyD＆lt; std :: unordered_set＆lt; int＆gt;＆gt;生成优先版本，在任意两个实例上调用运算符＆lt;（），在两个std :: unordered_set＆lt; int＆gt;上构建lessF（）的参数（任何的模板化构造函数不是“显式”定义的），然后，递归地调用自身，进入循环并生成错误（“Errore di segmentazione”，即“分段错误”）。

我想了解的是：

根据ISO c ++ 11，它是正确的clang ++行为还是g ++的行为？
我可以在本地阻止（仅在lessF（）中），并且不声明“显式”任何（）的模板构造函数，即两个std :: unordered_set＆lt; int＆gt;之间的比较会在两个人之间的对抗中变成自己吗？换句话说：如何防止在任何D＆lt; std :: unordered_set＆lt; int＆gt;＆gt;中开发lessF（）的优先版本？

以下是两个计划的产出。

---- clang++ program output ----
ai < 13 ? 1
as < std::string {"t0"} ? 0
au < std::unordered_set<int> { 2, 3, 4 } ? 
main(): standard exception of type "St13runtime_error"
  ---> no operator < for type  <---

---- end output ----

---- g++ program output ----
ai < 13 ? 1
as < std::string {"t0"} ? 0
Errore di segmentazione
---- end output ----

Answer 1

我相信你已经发现了gcc中的一个错误（我已经用更短的形式复制了here，敬请期待。）

问题是，如果您查看分段错误，您会看到operator<对unordered_set<int>的调用是无限递归的。这是因为gcc实际上认为bool operator<(const any&, const any&)是匹配的。它不应该是你打电话的地方。

简单的解决方法是简单地确保为operator<(const any&, const any&)找到any仅，无论您使用的是什么命名空间。只需将定义移到类：

class any {
    friend bool operator< (any const & a0, any const & a1) {
        return a0.opLess(a1);
    }
};

无论如何，这是一种很好的做法。

g ++和clang ++使用运算符＆lt;（）重载

1 个答案: