Effective C++笔记_条款46 需要类型转换时请为模板定义非成员函数

   看这个章节的时候又跑回去看了一下 条款 24，本章的例子就是基于下面这个例子而来的。在 item 24 中，支持混合运算的示例代码如下：

class Rational {
       public:
           Rational(int numerator = 0, int denominator = 1);
           int mumerator() const;
           int denominator() const;
       private:
           int numerator;
           int denominator;
   };
   const Rational operator* (const Rational& lhs, const Rational& rhs) const
   {
           return Rational(lhs.mumerator() * rhs.mumerator(), 
                       lhs.denominator() * rhs.denominator());
   }
   Rational oneFourth(1, 4);
   Rational result;
   result = oneFourth * 2;                    // ok
   result = 2 * oneFourth;                    // ok

 item 24 中的结束语是这么写的：

　　如果需要为某个函数的所有参数，包括被 this 指针所指的那个隐喻参数，进行类型转换，那么这个函数必须是个 non-member. 

记住上面这句话，本章节就是在此基础上进行的扩展。

---

 

   现在开始进入正题了，现在将它们模板化，代码如下：

template <typename T>
  class Rational {
      public:
           Rational(const T& numerator = 0, const T& denominator = 1);
           const T mumerator() const;
           const T denominator() const;
           //...
       private:
           T numerator;
           T denominator;
  };

  template<typename T>
  const Rational<T operator* (const Rational<T& lhs, const Rational<T& rhs) const
   {
           return Rational(lhs.mumerator() * rhs.mumerator(), 
                       lhs.denominator() * rhs.denominator());
   }

   Rational<int> oneHalf(1, 2);
   Rational<int> result = oneHalf * 2;     // 错误！无法通过编译

问题分析：
     编译器知道我们尝试调用什么函数，但这里编译器不知道我们想要调用哪个函数。它会尽它所能做些事情：它试图想什么函数被名为 operator* 的 template 具现化（产生）出来（参数推导）。
     为了推导 T，它会看 operator* 调用动作汇总的实参类型，每个参数分开考虑。但是一定要切记：template 实参推导过程中从不将隐式类型转换寒素纳入考虑。绝不！
     具体来说，函数调用过程中的确是可以使用隐式转换，但是在能够调用一个函数之前，首先必须知道那个函数存在（函数的签名信息）。而为了知道它，必须先为相关的 function template 推导出参数类型，然后才可将适当的函数具现化出来。然而 template 实参推导过程中不考虑 “通过构造函数而发生的”隐式类型转换。就本例而言，在看到 2 (int 类型) 时，它不能使用 non-explicit 构造函数将 2 转换为Rational<int>,进而将 T 推导为 int。

---

    那么怎么解决这个问题，使用 template class 内的 friend 声明式可以指涉某个特定函数。因为 class template 不依赖 template 实参推导（只施行于 function templates 身上），所以编译其总能够在 class Rational<T>具现化时得知 T。 因此可以将 operator* 声明为 friend 函数。代码如下：

/* 这段代码可以通过编译，但是不能连接 */
  template <typename T>
  class Rational {
      // (1)
      friend const Rational operator*(const Rational& lhs, const Rational& rhs);
      // friend const Rational<T> operator*(const Rational<T>& lhs, const Rational<T>& rhs); 等价的
      public:
           Rational(const T& numerator = 0, const T& denominator = 1);
           const T mumerator() const;
           const T denominator() const;
           //...
       private:
           T numerator;
           T denominator;
  };

  // (2)
  template<typename T>
  const Rational<T operator* (const Rational<T>& lhs, const Rational<T>& rhs) const
   {
           return Rational(lhs.mumerator() * rhs.mumerator(), 
                       lhs.denominator() * rhs.denominator());
   } 
   Rational<int> oneHalf(1, 2);
   Rational<int> result = oneHalf * 2;     // ok! :) 通过编译,但是无法连接 :(

分析原因：
    混合式代码通过了编译，因为编译器知道要调用哪个函数（1），但（1）函数只被声明 Rational 内，并没有被定义出来。我们意图令此 class 外部的 operator * template 提供定义式，但是行不通。如果我们自己声明了一个函数，就有责任定义那个函数。 既然我们没有提供定义式，连接器当然找不到它！

---

解决方法有两个：
（1）将 operator* 函数体合并至其申明式内

template <typename T>
  class Rational {
      // (1)
      friend const Rational operator*(const Rational& lhs, const Rational& rhs)
      {
          return Rational(lhs.mumerator() * rhs.mumerator(),
                          lhs.denominator() * rhs.denominator());
      }
      // friend const Rational<T> operator*(const Rational<T>& lhs, const Rational<T>& rhs); 等价的
      public:
           Rational(const T& numerator = 0, const T& denominator = 1);
           const T mumerator() const;
           const T denominator() const;
           //...
       private:
           T numerator;
           T denominator;
  };

   看到上面的实现，虽然使用 friend,却与 friend 的传统用途 "访问class的 non-public 成分"毫不相关。为了让类型转换发生于所有实参身上，我们需要一个 non-member 函数；为了领这个函数被自动具现化，我们需要将它声明在 class 内部；而在 class 内部声明 non-member 函数的唯一办法就是：令函数成为一个 friend。

(2) 定义于 class 内的函数都暗自成为 inline，包括像 operator* 这样的 friend 函数。为了将这样的inline 声明所带来的冲击最小化，做法是 operator* 啥都不干，只调用一个定义于 class 外部的辅助函数。

// 外部的辅助函数
template<typename T>
const Rational<T> doMultiply(const Rational<T>& lhs, const Rational<T>& rhs)
{
    return Rational<T>(lhs.mumerator() * rhs.mumerator(),
                          lhs.denominator() * rhs.denominator());
}
template <typename T>
class Rational {
    // (1)
    friend const Rational operator*(const Rational& lhs, const Rational& rhs)
    {
        return doMultiply(lhs, rhs);
    }
    // friend const Rational<T> operator*(const Rational<T>& lhs, const Rational<T>& rhs); 等价的
    public:
        Rational(const T& numerator = 0, const T& denominator = 1);
        const T mumerator() const;
        const T denominator() const;
        //...
    private:
        T numerator;
        T denominator;
};

总结：
     当我们编写一个 class template, 而它所提供的“与此 template 相关的” 函数支持 “所有参数之隐式类型转换”时，请将那些函数定义为 "class template 内部的 friend 函数"。

---

声明：全文文字都是来源《Effective C++》 3th。这里所写都是自己的读书的时候梳理做的笔记罢了。希望对他人有用，那是我的荣幸。