“听说最近新开了家超市？”
“是啊，我去过了，什么都没有！”
“真的？什么都没有？”
“我骗你干什么！只有些牙膏、牙刷、洗衣粉……真的什么都没有。”
习以为常的东西总是容易被忽略。在生活中我们可以对这些经常见到的东西视而不见，但在代码中千万不要这样作。
问题：下面这个类有几个成员函数？
class X
{
int value;
};
“这么简单的问题还问！我当然知道，编译器会为没有构造函数的类生成一个缺省构造函数，为没有拷贝构造函数的类生成一个拷贝构造函数，为没有析构函数的类生成一个析构函数，为没有拷贝赋值操作符的类生成一个拷贝赋值操作符，所以它有四个隐含成员函数。”
是的，回答是正确的，但仅限于知道是不行的，必须把它牢牢的记住，直到你一看到这个定义眼前就能浮现出下面的定义：
class X
{
int Value;
public:
X();
X(const X&);
X& operator = (const X&);
~X();
};
为什么这样说呢？因为尽管在回答上面的问题时大家都能答对，但在实际应用时却常常把它忽略掉。让我们看一个例子：
比如我们要实现一个“智能指针”（什么类型的？什么类型都行，这与本题无关），这，通常都会这样写：
template <typename T>
smart_ptr...
现在我们要为它写一个拷贝构造函数和一个拷贝赋值操作符……等一下。
我们这个智能指针是为了在某一应用范围内代替指针的，我们应该让它支持指针的一些特性，如自动类型转换的初始化（拷贝构造）和赋值。而类模板和真正的指针是不一样的，即使一个Derived*是一个Base*，但一个smart_ptr<Derived>却不是一个smart_ptr<Base>，从smart_ptr<Derived>到smart_ptr<Base>的转换不是编译器自动支持的，我们必须为它写一些代码来做这件事。该怎么做呢？很简单：
template <typename T>
smart_ptr
{
T* ptr_data;
public:
T* get_ptr();
template<typename U>
smart_ptr(const smart_ptr<U> & Source)
{
ptr_data = Source.get_ptr();
//其它处理
}
template<typename U>
smart_ptr<T> & operator = (const smart_ptr<U> & Source)
{
ptr_data = Source.get_ptr();
//其它处理
}
};
这样当我们用smart_ptr<Derived>初始化smart_ptr<Base>的时候，编译器会自动为smart_ptr<Base>类生成一个参数为const smart_ptr<Derived>& 的构造函数，用smart_ptr<Derived>::get_ptr()的返回值（类型为Derived*）初始化smart_ptr<Base>::ptr_data（类型为Base*），而编译器会在这里进行类型检查，其检查结果和直接使用指针类型时一样。现在你松了一口气——一切OK，大功告成……可是你错了！
当你写下这样一段代码时：
smart_ptr<int> a;
...
smart_ptr<int> b(a);
smart_ptr<int> c;
c = a;
你会发现，它并没有调用你的构造函数的赋值操作符。什么原因呢？原因很简单：当你没有写拷贝构造函数时，编译器会为你生成一个隐含的拷贝构造函数。而拷贝构造函数的定义是“类X的拷贝构造函数是指第一个参数为const X&、X&、volatile X&或const volatile X&，并且没有其它参数或其它参数都有缺省值的非模板形式的构造函数”，因此上template<typename U>smart_ptr(const smart_ptr<U> & Source)这个构造函数并不是拷贝构造函数注，由于这个原因，编译器会为你生成一个隐含的拷贝构造函数。事实上你的类是这个样子的：
template <typename T>
smart_ptr
{
T* ptr_data;
public:
T* get_ptr();
//以下是编译器自动生成的三个成员函数
smart_ptr(const smart_ptr<T>&);
smart_ptr<T>& operator = (const smart_ptr<T>&);
~smart_ptr();
template<typename U>
smart_ptr(const smart_ptr<U> & Source)
{
ptr_data = Source.get_ptr();
//其它处理
}
template<typename U>
smart_ptr<T> & operator = (const smart_ptr<U> & Source)
{
ptr_data = Source.get_ptr();
//其它处理
}
};
现在我们看的很清楚了：由于smart_ptr(const smart_ptr<T>&);这个函数的存在，在编译代码smart_ptr<int> b(a);编译器找到了一个类型符合的非模板构造函数，它就会调用这个函数而不会去实例化你的模板形式的构造函数。同样道理，你的模板形式的赋值操作符也不是拷贝赋值操作符，编译器同样会为你生成一个从而阻止了模板的实例化。
解决办法很简单，既然编译器要调用拷贝构造函数和拷贝赋值操作符，而隐含的成员又不符合要求，我们就自己写一个来代替它们：
template <typename T>
smart_ptr
{
T* ptr_data;
public:
T* get_ptr() const;//返回封装的指针，可能还需要做一些附加操作，取决于你的智能指针的设计逻辑。
//自己的拷贝构造函数和拷贝赋值操作符：
smart_ptr(const smart_ptr<T>&)
{
ptr_data = Source.get_ptr();
//其它处理
}
smart_ptr<T>& operator = (const smart_ptr<T>&);
{
ptr_data = Source.get_ptr();
//其它处理
}
template<typename U>
smart_ptr(const smart_ptr<U> & Source)
{
ptr_data = Source.get_ptr();
//其它处理
}
template<typename U>
smart_ptr<T> & operator = (const smart_ptr<U> & Source)
{
ptr_data = Source.get_ptr();
//其它处理
}
};
事实上在《C++ STL中文版》中auto_ptr的实现代码中就是这样实现的。
注：在Nicolai M.Josuttis编写的《C++ 标准程式库》（我读的是侯捷和孟岩的译本）中把这种构造函数称为“模板形式的拷贝构造函数”（原译文为“template形式的copy建构式”）是一种不很严密的说法，容易让人误解。事实上这种模板形式的构造函数不属于拷贝构造函数。
