Effective C++: 关于模板成员函数.

运用好模板成员函数可以使得当前class具有兼容性:

比如我们定义了一个template-class: Node<T>接着我们实例化出来Node<int> first_(5)和Node<double> second_(0.5),我们想让first_ = second.怎么办呢，这个时候模板成员函数就派上了用场.

我们一般称:模板成员函数为 泛化成员函数.

泛化的成员模板随之也带来两个问题,这要追溯二个性质:

1,就是两个分别实例化的模板是没有联系的。比如Node<int>(5)和Node<int>(6)这两个实例化的结果就像马嘴和牛屁股没有任何联系.

2,泛化构成员函数并不会影响编译器合成自己的拷贝构造函数，移动构造函数，拷贝复制运算符，移动赋值运算符.....因此我们要想获得对当前template-class的精确控制也必须声明定义出来这些函数.

我们来看一下代码吧:

 #include <iostream>

template<typename T>
class Node{
 private:
  T key_;
  
  public:
   Node()=default;
   
   template<typename Ty>
   explicit Node(const Ty& key); //这里的explicit确保接受T类型的参数的时候才会被调用. 
   
   Node(const Node<T>& other_node_); //普通拷贝构造函数. 
   
   template<typename Ty>
   Node(const Node<Ty>& other_node_); //泛化拷贝构造函数. 
   
   template<typename Ty>
   Node(Node<Ty>&& other_node_); //泛化移动构造函数. 
   
   Node(Node<T>& other_node_); //普通移动构造函数.
   
   Node<int>& operator=(const Node<Ty>& other_node_); //普通拷贝赋值运算符. 
   
   template<typename Ty>
   Node<Ty>& operator=(const Node<Ty>& other_node_); //泛化拷贝复制运算符. 
   
   Node<T>& operator=(Node<T>&& other_node_);       //普通移动复制运算符. 
   
   template<typename Ty>
   Node<Ty>& operator=(Node<T>&& other_node_);   //泛化移动赋值运算符. 
   
   inline const T& get()const
   {
    return this->key_;
   }
   
   inline void print()const
   {
    std::cout<<"key_: "<<this->key_<<std::endl;
   }
   
   ~Node()=default;
};

template<typename T>
template<typename Ty>
Node<T>::Node(const Ty& key)
        :key_(key)
{
 //
}

template<typename T>
template<typename Ty>
Node<T>::Node(const Node<Ty>& other_node_)
        :key_(other_node_.get()) //如果这里写成key_(other_node_.key_)会报错: key_在other_node_中是private的。
                           //为什么会这样呢？因为Node<Ty>的每次实例子化出来的总是与其他实例化出来的Node没有任何联系.
         //比如Node<int>(5)和Node<int>(6),这两个实例化出来的Node没有任何关系. 
{
 //
 std::cout<<"泛化."<<std::endl;
}

template<typename T>
Node<T>::Node(const Node<T>& other_node_)
        :key_(other_node_.key_) //注意这里就没有问题. 
{
 //
 std::cout<<"--------------------"<<std::endl; 
}

int main()
{                                                                 // template<typename Ty>
 Node<int> first_ = Node<double>(3.14); //调用 泛化拷贝构造函数.  Node<T>::Node(const Node<Ty>& other_node_)
 first_.print();
 
 Node<int> third_ (Node<int>(5)); //调用 普通拷贝构造函数. Node<T>::Node(const Node<T>& other_node_)
 
 Node<int> forth_(0.5);
 
 return 0;
}