c++ - 类模板中的运算符重载和友元

Question

假设我有一个小类模板如下

template<typename T> class SillyClass {
public:

  SillyClass(const T val);
  SillyClass(const SillyClass& other);

private:

  T data;

};

现在我添加以下 definitions 声明:

template<typename T> class SillyClass {
public:

  SillyClass(const T val);
  SillyClass(const SillyClass& other);

  SillyClass<T> operator+ (const SillyClass& other);
  SillyClass<T> operator+ (const T& val);

private:

  T data;

};

现在(在我写下适当的定义之后)我可以做类似的事情

SillyClass<int> a(1);
SillyClass<int> b(a);
SillyClass<int> c = a + b;
SillyClass<int> d = a + 3;

到目前为止，还不错。然而，为了能够写出类似的东西

SillyClass<int> e = 3 + a;

我发现必须在我的类中添加以下声明

  template<typename T2> friend SillyClass<T2> operator+ 
    (const T2& val, const SillyClass<T2>& other);

现在是这样写的

template<typename T> class SillyClass {
public:

  SillyClass(const T val);
  SillyClass(const SillyClass& other);

  SillyClass<T> operator+ (const SillyClass& other);
  SillyClass<T> operator+ (const T& val);

  template<typename TT> SillyClass<TT> friend operator+ 
    (const TT& val, const SillyClass<TT>& other);

private:

  T data;

};

我没有在书中找到这个，我想要一些帮助来理解最后一个声明中发生的事情。例如，我的类(class)在这里结识了什么？为什么要附加模板声明？对于导致相同结果的不同声明(例如，能够执行 3+a)，我有哪些替代方案？

谢谢。

Answer 1

with what is my class being befriended here? Why the additional template declaration?

在您的类中声明的以下表达式是 friend declaration :

template<typename TT> SillyClass<TT> friend operator+ 
    (const TT& val, const SillyClass<TT>& other);

上面的表达式声明你的类(class)有一个重载的家庭 friend operator+将类型 TT 作为其左侧参数的 s并作为他们的右侧对象SillyClass<TT> .请注意，这是声明而不是定义。也就是说，为了使其工作，模板重载了 operator+ , 必须定义。

What alternatives do I have in terms of different declarations that lead to the same result (being able to perform 3+a, say)?

对于二元运算符，为了使它们对称，必须在类定义之外声明为自由函数，并且为了访问其类参数的私有(private)成员，您将它们声明为相应类的友元函数。

基于这些思路，我将采用以下实现方式:

template<typename T> class SillyClass {
  T data;
public:
  SillyClass(const T val) : data(val) {}
  SillyClass(const SillyClass& other) : data(other.data) {}

  template<typename T1, typename T2>
  friend SillyClass<typename std::common_type<T1, T2>::type> 
  operator+(SillyClass<T1> const &lsh, SillyClass<T2>& rhs);

  template<typename T1, typename T2>
  friend SillyClass<typename std::common_type<T1, T2>::type> 
  operator+(SillyClass<T1> const &lsh, T2 const &rhs);

  template<typename T1, typename T2>
  friend SillyClass<typename std::common_type<T1, T2>::type> 
  operator+(T1 const &rhs, SillyClass<T2> const &rsh);
};

template<typename T1, typename T2>
SillyClass<typename std::common_type<T1, T2>::type> 
operator+(SillyClass<T1> const &lhs, SillyClass<T2>& rhs) {
  return SillyClass<typename std::common_type<T1, T2>::type>(lhs.data + rhs.data);
}

template<typename T1, typename T2>
SillyClass<typename std::common_type<T1, T2>::type> 
operator+(SillyClass<T1> const &lhs, T2 const &rhs) {
  return SillyClass<typename std::common_type<T1, T2>::type>(lhs.data + rhs);
}

template<typename T1, typename T2>
SillyClass<typename std::common_type<T1, T2>::type> 
operator+(T1 const &lhs, SillyClass<T2> const &rhs) {
  return SillyClass<typename std::common_type<T1, T2>::type>(rhs.data + lhs);
}

Live Demo