如何模板重载一组相关类的运算符而不与标准库运算符冲突？

Question

这似乎是一个相当直接的想法：我有一组类，我应该能够为它们编写一个运算符，比如说减法，使用基本完全相同的代码。

当尝试以“明显”的方式执行此操作时，即：

template <typename T>
T operator-(T a, const T& b) {
    return a -= b;
}

然后，在某些编译器上，这似乎与迭代器的减法运算符冲突（特别是它在 gcc 3.4.6 和 Apple LLVM 上中断，而在 gcc 版本 4 或更高版本上似乎工作正常），我收到以下错误：

 error: use of overloaded operator '-' is ambiguous (with operand types 'std::__1::__wrap_iter<const double *>' and 'const_iterator'
      (aka '__wrap_iter<const_pointer>')) 

我还考虑过模板重载只是一个基类，组中的所有类都将从该基类派生，但是由于第一个参数是按值传递的，我认为特定于子类的信息会在复制。

我是否遗漏了一些明显的东西？有没有办法让所有这些编译器都满意？

编辑：理想情况下，该解决方案应该在 C++03 中运行。

Answer 1

使用基类、adl koenig 运算符和 sfinae。

namespace ops{
  struct subtract_support{
    template<class T,
      std::enable_if_t<std::is_base_of<subtract_support, T>{}, int> =0
    >
    friend T operator-( T lhs, T const& rhs ){
      lhs-=rhs;
      return lhs;
    }
  };
}

现在从ops::subtract_support 继承会导致- 适用于您的类型。 （注意两行正文：确保 lhs 移出-，与您在 OP 中的版本不同）。

仅命名空间限制会导致您的 - 被发现任何模板生成的类型，其中 tge 参数之一来自您的命名空间，以及其他意外情况：adl 对模板成员来自特定命名空间的类型进行操作。¹

此技巧可让您在声明时将每种类型标记为使用此技术。

这种技术对二进制布局的影响几乎为零。但是，如果您需要一些模糊的东西，例如前缀的布局兼容性，则可能需要使用特性类。

---

现在，这是一个 C++11 解决方案。显然OP需要C++ 03。好吧，最好的方法是像 C++11 一样实现它，这样在升级编译器时可以删除代码。

enable_if 可以很容易地用 C++03 编写。 is_base_of 多写几行：

namespace notstd{
  namespace details{
    template<class T, class U>
    struct base_test{
      typedef char no; // sizeof(1)
      struct yes { no unused[2]; }; // sizeof(2) or greater
      static yes test(T*); // overload if arg is convertible-to-T*
      static no test(...); // only picked if first overload fails
      // pass a `U*` to `test`.  If the result is `yes`, T
      // is a base of U.  Note that inaccessible bases might fail here(?)
      // but we are notstd, good enough.
      enum {value= (
        sizeof(yes)==sizeof(test((U*)0))
      )};
    };
  }
  template<class Base, class T>
  struct is_base_of{
    enum{value=details::base_test<Base,T>::value};
  };
  template<bool b, class T=void>
  struct enable_if {};
  template<class T>
  struct enable_if<true, T> {
    typedef T type;
  };
}

我们还需要调整模板 ADL 运算符中的 SFINAE 以符合 C++03：

namespace ops{
  struct subtract_support{
    template<class T>
    friend
    typename notstd::enable_if<notstd::is_base_of<subtract_support, T>::value, T>::type
    operator-( T lhs, T const& rhs ){
      lhs-=rhs;
      return lhs;
    }
  };
}

Live example.

---

¹ 举个例子，如果Foo 是命名空间中带有贪婪- 模板运算符的类型，那么decltype(v0-v1) 其中v0 和v1 是vector<Foo>将是vector<Foo>。这是一个误报（它不会编译）。但是带有自己的- 的vec3<Foo>（3 Foo 的向量空间）会导致同样的歧义。

Answer 2

将此模板和您的自定义数据结构放在同一个命名空间中（如果它们在根命名空间中 - 只需移动它们）。

因为argument-dependent lookup，编译器会在你的结构的命名空间中寻找这个操作符，并且没有问题和歧义地找到它。

Answer 3

在 C++11 中，std::enable_if 和 std::is_base_of 可能对您有所帮助。假设你有一个基类Base:

template <typename T, typename = std::enable_if_t<std::is_base_of<Base, T>::value>>
T operator-(T a, const T& b) {
        return a -= b;
}

这里您的运算符将只考虑从Base派生的类型T。

编辑：

cppreference.com 的链接页面显示了可能的实现，因此您也可以在 C++03 中使用它们，只需实现您自己的 enable_if 和 is_base_of。

Answer 4

遍历Yakk's answer 你可以使用简单的 sfinea 来完成它，只需一个额外的特征。 c++03兼容代码：

namespace ops{
  struct subtract_support{
    template <class T>
    struct subtract_support_trait {
        typedef T type;
    };
    template<class T>
    friend typename T::template subtract_support_trait<T>::type operator-( T lhs, T const& rhs ){
      lhs-=rhs;
      return lhs;
    }
  };
}

[live demo]