读书笔记_Effective_C++_条款四十五：运用成员函数模板接受所有兼容类型

比如有一个Base类和一个Derived类，像下面这样：

 class BaseClass
 {…};

 class DerivedClass : public BaseClass
 {…};

因为是父类与子类的关系，所以可以这样写：

 DerivedClass *d;
 BaseClass *b = static_cast< BaseClass *>d; // 用C风格直接是 b = (BaseClass*) d;

我们可以弄一个简易的Shared型智能指针类，如果直接像下面这样写：

 template <class T>
 class SharedPtr
 {
 private:
     T* Ptr;
     static size_t Count;

 public:
     SharedPtr(T* _ptr)
     {
         Count = ;
         Ptr = _ptr;
         cout << "Constructor Called Same" << endl;
     }
     ~SharedPtr()
     {
         cout << "Destructor Called" << endl;
         if (--Count == )
         {
             cout << "Delete Pointer" << endl;
             delete Ptr;
             Ptr = NULL;
         }
     }

     SharedPtr(const SharedPtr<T>& _Smart)
     {
         cout << "Copy Constructor Called Same" << endl;
         Ptr = _Smart.Ptr;
         ++Count;
     }
 };

那么显示编译器不会允许SharedPtr<BaseClass> pb(pd)，因为在编译期替换T时，拷贝构造函数明确了接受类型必须是SharedPtr<BaseClass>，而由SharedPtr<DerivedClass>对象至SharedPtr<BaseClass>的转换并不存在，所以编译器报错。

为了能使这样的转换合法，我们需要在原来的基础上这样写：

 class SharedPtr
 {
 private:
     T* Ptr;
     static size_t Count;

 public:
     SharedPtr(T* _ptr)
     {
         Count = ;
         Ptr = _ptr;
         cout << "Constructor Called Same" << endl;
     }

15     template <class Other>
16     SharedPtr(Other* _ptr)
17     {
18         Count = 1;
19         Ptr = static_cast<T*> (_ptr);
20         cout << "Constructor Called Other" << endl;
21     }

     ~SharedPtr()
     {
         cout << "Destructor Called" << endl;
         if (--Count == )
         {
             cout << "Delete Pointer" << endl;
             delete Ptr;
             Ptr = NULL;
         }
     }

     T* GetPointer()
     {
         return Ptr;
     }

     T* GetPointer() const
     {
         return Ptr;
     }

     SharedPtr(const SharedPtr<T>& _Smart)
     {
         cout << "Copy Constructor Called Same" << endl;
         Ptr = _Smart.Ptr;
         ++Count;
     }

52     template <class Other>
53     SharedPtr(const SharedPtr<Other>& _Smart)
54     {
55         cout << "Copy Constructor Called Other" << endl;
56         Ptr = static_cast<T*>(_Smart.GetPointer());
57         ++Count;
58     }
 };

注意代码标注为蓝色的部分（即为泛化部分），这里另外声明了一个模板参数Other，它可以与T相同，也可以不同，也就意味着它可以接受任何可以转化成T的类型了，比如父子类。这里还定义了GetPointer的方法，因为拷贝构建中传入的对象不一定是属于同一个类的，所以不能保证可以访问到类的私有成员。Ptr = static_cast<T*>(_Smart.GetPointer())这句话其实就是转换的实质了，只要任何可以转成T*的Other*，都是可以通过编译的，但如果是风马牛不相及的两个类，就不会通过编译。这里有一点要强调一下，我们可以把double转成int（窄化），也可以把int转成double（宽化），但注意double*与int*之间是不能相互转的，如果这样写int *a = (int*) (new double(2))，是不能通过编译的，可以用static_cast转换的类要有继承关系。代码还有赋值运算符也需要提供一个非泛化的版本和泛化的版本，这里简略没有写出。

这里还有一个需要注意的地方，在class类声明泛化copy构造函数（member template），并不会阻止编译器生成它们自己的copy构造函数（non-template），换言之，如果程序中只写了泛化的copy构造函数，那么编译器还是会自动生成一个非泛化的版本出来，如果不想要这个缺省版本，那一定不能偷懒，要两个版本的copy构造函数都要写。

最后总结一下：

1. 请使用member function templates（成员函数模板）生成“可接受所有兼容类型”的函数；

2. 如果你声明member templates用于“泛化copy构造”或“泛化assignment操作”，你还是需要声明正常的copy构造函数和copy assignment操作符。

下面附上微软对shared_ptr类的声明，对比黄色加亮部分，可以看到本条款所说的技术要点。

 template<class Ty>
    class shared_ptr {
 public:
     typedef Ty element_type;

     shared_ptr();
     shared_ptr(nullptr_t);
     shared_ptr(const shared_ptr& sp);
     shared_ptr(shared_ptr&& sp);
     template<class Other>
         explicit shared_ptr(Other * ptr);
     template<class Other, class D>
         shared_ptr(Other * ptr, D dtor);
     template<class D>
         shared_ptr(nullptr_t, D dtor);
     template<class Other, class D, class A>
         shared_ptr(Other *ptr, D dtor, A alloc);
     template<class D, class A>
         shared_ptr(nullptr_t, D dtor, A alloc);
     template<class Other>
         shared_ptr(const shared_ptr<Other>& sp);
     template<class Other>
         shared_ptr(const shared_ptr<Other>&& sp);
     template<class Other>
         explicit shared_ptr(const weak_ptr<Other>& wp);
     template<class Other>
         shared_ptr(auto_ptr<Other>& ap);
     template<class Other, class D>
         shared_ptr(unique_ptr<Other, D>&& up);
     template<class Other>
         shared_ptr(const shared_ptr<Other>& sp, Ty *ptr);
     ~shared_ptr();
     shared_ptr& operator=(const shared_ptr& sp);
     template<class Other>
         shared_ptr& operator=(const shared_ptr<Other>& sp);
     shared_ptr& operator=(shared_ptr&& sp);
     template<class Other>
         shared_ptr& operator=(shared_ptr<Other>&& sp);
     template<class Other>
         shared_ptr& operator=(auto_ptr< Other >&& ap);
     template <class Other, class D>
         shared_ptr& operator=(const unique_ptr< Other, D>& up) = delete;
     template <class Other, class D>
         shared_ptr& operator=(unique_ptr<Other, D>&& up);
     void swap(shared_ptr& sp);
     void reset();
     template<class Other>
         void reset(Other *ptr);
     template<class Other, class D>
         void reset(Other *ptr, D dtor);
     template<class Other, class D, class A>
         void reset(Other *ptr, D dtor, A alloc);
     Ty *get() const;
     Ty& operator*() const;
     Ty *operator->() const;
     long use_count() const;
     bool unique() const;
     operator bool() const;

     template<class Other>
         bool owner_before(shared_ptr<Other> const& ptr) const;
     template<class Other>
         bool owner_before(weak_ptr<Other> const& ptr) const;
     template<class D, class Ty>
         D* get_deleter(shared_ptr<Ty> const& ptr);
 };