此條款意思大概就是說在類模板中，在copy構造與賦值操作中要相容所有可能型別。

考慮一下程式碼：

template<class T>
class C
{
public:
	C(T a) :m_t(a) {}
	C(const C& c) 
	{
		cout << "copy 1" << endl;
	}
	template<class U>
	C(const C<U>& c)
	{
		cout << "copy 2" << endl;
	}

	C& operator=(const C&)
	{
		cout << "operator 1" << endl;
		return *this;
	}
	template<class U>
	C& operator=(const C<U>&)
	{
		cout << "operator 2" << endl;
		return *this;
	}

private:
	T m_t;

};

void main()
{
	
	C<int>c(10);
	C<int>c2(c);// 以C<int>型別構造 C<int>型別
	C<double> c3(c);//以C<int>型別構造 C<double>型別
	
	C<int>c4(0);
	C<double>c5(0);
	
	c = c4; //C<int>型別賦值給C<int>
	c2 = c5; //C<double>型別賦值給C<int>


	system("pause");	
}
 

輸出為：

copy 1 copy 2 operator 1 operator 2

如果想控制copy構造的方方面面就必須要同時宣告泛化copy構造與正常的copy構造。此處只給出了同類型的與不同型別的兩種。也可以更具體的給出其他型別。書上例項如下

template<class T>
class shared_ptr
{
public:
	template<class Y>                                   // 構造，來自任何相容的
	explicit shared_ptr(Y* p);                         //內建指標
	template<class Y>
	shared_ptr(shared_ptr<Y> const& r);                //或shared_ptr、
	template<class Y>
	explicit shared_ptr(weak_ptr<Y> const& r);         //或weak_ptr、
	template<class Y>
	explicit shared_ptr(auto_ptr<Y>& r);               //或auto_ptr  
	template<class Y>                                        //賦值，來自任何相容的
	shared_ptr& operator=(shared_ptr<Y> const& r);           //shared_ptr
	template<class Y>                                                                 
	shared_ptr& operator=(auto_ptr<Y>& r);                    //或auto_ptr
};