Effective C++ 45. Use member function templates to accept "all compatible types."

I

class Top { };class Middle: public Top{ };class Bottom: public Middle { };Top *pt1 = new Middle;Top *pt2 = new Bottom;const Top *pt2 = pt1;

tmplate<typename T>class SmartPtr {public:explicit SmartPtr(T* realPtr);};SmartPtr<Top> pt1 = SmartPtr<Middle>(new Middle);

There is no inherent relationship among different instantiations of the same template, so compilers view SmartPtr<Middlet> and SmartPtr<Top> as completely different classes.

template<typename T>class SmartPtr {public:    template<typename U>    SmartPtr(const SmartPtr<U>& other);};

we want to be able to create a SmartPtr<Top> from a SmartPtr<Bottom>, but we do not want to be able to create a SmartPtr<Bottom> from a SmartPtr<Top>, as that’s contray to the meaning of public inheritance.
I.I

template<typename T>class SmartPtr{public:    template<typename U>    SmartPtr(const SmartPtr<U>& other): heldPtr(other.get()) { }    T* get() const { return heldPtr; };private:    T* heldPtr;};

heldPtr(other.get()) this will compile only if there is an impilcit conversion from a U* pointer to a T* pointer, and that is precisely what we want.

II.
Declaring a generalized copy constrctor (a member template) in a class doesn’t keeep compilers from generating their own copy constructor, so if you want to control all aspects of copy construction, you must declare both a generalized copy constructor as well as the “normal” copy constructor.

template<typename T> clas shared_ptr {public:    // copy constructor    shared_ptr(shared_ptr const& r);    // generalized copy constructor    template<typename Y>        shared_ptr(shared_ptr<Y> const& r);    // copy assignment     shared_ptr& operator=(shared_ptr const& r);    // generalized copy assignment    template<class Y>        shared_ptr& operator = (shared_ptr<Y> const& r);};