Generalized copy constructors

Question

Why do classes like shared_ptr have another template in their constructors?

For example:

template<class T> class shared_ptr {
public:
  template<class Y>
  explicit shared_ptr(Y * p);

I've been reading Scott Meyers's Effective C++, item 45, which says the idea behind it is to make polymorphism possible through them; that is, construct shared_ptr<A> from shared_ptr<B> if B is derived from A.

But isn't defining a constructor like

explicit shared_ptr(T * p);

enough? I mean, this code works just fine:

class C1 {
};

class C2 : public C1 {
};

template<typename T>
class A
{
public:
  A(T &a)
  {
    var1 = a;
  }

  T var1;
};

int main(int argc, char *argv[])
{
  C2 c2;
  A<C1> inst1(c2);
}

So why do we need another template for constructor there?

Answer 1

Without the template constructor, the following code would have undefined behavior:

#include <memory>

class Base {};
class Derived : public Base {};

int main() {
    std::shared_ptr<Base> ptr( new Derived );
}

If shared_ptr takes only a Base*, it is forced to eventually call delete on that Base* pointer. But since Base does not have a virtual destructor and the pointer actually points at Derived, this is undefined behavior.

But in reality, the code above is well-formed. The template constructor for shared_ptr takes a Derived* pointer and stores a custom deleter that calls delete on the original Derived* pointer, which is fine.