一个类模板的两个实例化之间的 C++ 朋友比较

Question

我正在尝试编写一个类模板，该模板在具有不同模板类型的两个实例之间提供比较运算符。通常情况下，此操作员是非会员朋友。下面是我尝试实现的简化示例。

template<typename T>
class Wrapper {
  // Base type, which must have a val() method to allow comparison
  T t_;
public:
  Wrapper(const T& t) : t_(t) {}

  // Comparison operator
  template<typename B>
  friend
  bool
  operator==(const Wrapper &a, const Wrapper<B>&b) {
    return a.t_.val()==b.t_.val();
  }
};

// First example type for Wrapper
class X {
  int x_;    
public:
  X(int x) : x_(x) {}

  int
  val() const {return x_;}
};

// Second example type for Wrapper
class Y {
  int y_;
public:
  Y(int y) : y_(y) {}

  int
  val() const {return 2*y_;}
};

int
main() {
  Wrapper<X> WX(X(4));
  Wrapper<Y> WY(Y(2));
  return WX==WY ? 1 : 0;
}

此示例 (g++ 4.4.0) 无法编译：相反，它抱怨来自 Wrapper<Y> 的 y_ 是私有的，因此无法访问朋友函数，我明白了原因。但是我该如何解决这个问题？给反转函数添加友谊

  template<typename B>
  friend bool operator==(const Wrapper<B> &, const Wrapper &);

进入 Wrapper 类模板体只会导致编译器产生歧义。我不想让 Wrapper 类的不同实例能够访问彼此的私有成员——我想限制对这个操作符的访问。这可能吗？

我的笔记本电脑因被关闭而处于危险之中，因此我和笔记本电脑（以及与此相关的窗口）都会接受任何想法。

Answer 1

事物的数量：

• 当您的类模板为X 和一次Y 实例化时，您有两个operator== 定义。

• 将operator== 移出类声明。

• 请注意，friend 不是成员。因此，访问冲突相关的诊断。

试试这个：

template<typename T>
class Wrapper {
  // Base type, which must have a val() method to allow comparison
  T t_;
public:
  Wrapper(const T& t) : t_(t) {}

  // Comparison operator

  template<typename A, typename B>
  friend bool
  operator==(const Wrapper<A> &a, const Wrapper<B>&b);
};

template<typename A, typename B>
  bool
  operator==(const Wrapper<A> &a, const Wrapper<B>&b) {
    return a.t_.val()==b.t_.val();
  }

// First example type for Wrapper
class X {
  int x_;    
public:
  X(int x) : x_(x) {}

  int
  val() const {return x_;}
};

// Second example type for Wrapper
class Y {
  int y_;
public:
  Y(int y) : y_(y) {}

  int
  val() const {return 2*y_;}
};

int
main() {
  Wrapper<X> WX(X(4));
  Wrapper<Y> WY(Y(2));
  return ::operator==(WX, WY) ? 1 : 0;
}

虽然我仍然不喜欢有两个可能的friend operator== 潜伏在那里......

Answer 2

我的笔记本电脑是安全的（目前），因为重新阅读 C++ FAQ-lite 会有所帮助，尽管该示例最初似乎与我自己的问题不匹配。下面通过将操作符的定义移到模板类主体之外来完成这项工作：

template <typename T> class Wrapper;

template<typename A, typename B>
inline
bool
operator==(const Wrapper<A> &a, const Wrapper<B>&b) {return a.t_.val()==b.t_.val();}

template<typename T>
class Wrapper {
  T t_;
public:
  Wrapper(const T& t) : t_(t) {}

  template<typename A, typename B>
  friend
  bool
  operator==(const Wrapper<A> &a, const Wrapper<B>&b);
};

任何更优雅或有见地的建议将不胜感激。