拷贝构造函数
有三种情况，会以一个object的内容作为另一个class object的初值。最明显的一种情况当然就是对一个object做明确得初始化操作，像这样：
class X{…};
X x;
//明确地以一个object的内容作为另一个class object的初值
X xx = x;
另两种情况是当object被当做参数交给某个函数时，以及当函数传回一个class object时。
假设class设计者明确定义了一个拷贝构造函数，像下面这样：
X::X( const X& x );
Y::Y( const Y& y, int = 0 );
那么在大部分情况下，当一个class object以另一个同类实体作为初值时，上述的拷贝构造函数就会被调用。这可能会导致一些临时性对象的产生或程序代码的蜕变。
Default Memberwise Initialization
如果类没有提供一个explicit copy constructor又当如何？当class object以相同类的另外一个object作为初值时，其内部是以所谓的default memberwise initialization手法完成的，也就是把每一个内建的或派生的data member的值，从某一个对象拷贝一份到另外一个对象身上。不过它并不会拷贝其中的member class object，而是以递归的方式施行memberwise initialization。例如，考虑下面这个类声明：
class String{
public:
//...
private:
char *str;
int len;
};
一个String object的default memberwise initialization发生在这种情况之下：
String noun(“book”);
String verb = noun;
其完成方式就好像个别设定每一个members一样：
//语意相等
verb.str = noun.str;
verb.len = noun.len;
如果一个String object被声明为另一个class的member，像下面这样：
class Word{
public:
//...
private:
int _occurs;
String _word;
};
那么一个Word object的default memberwise initialization会拷贝其内建的member _occurs，然后再于String member object _word身上递归实施memberwise initialization。
就像缺省构造函数一样，C++ Standard上说，如果类没有声明一个拷贝构造函数，就会有隐含的声明(implicitly declared)或隐含的定义(implicitly defined)出现。和以前一样，C++ Standard把拷贝构造函数区分为trivial和nontrivial两种。只有nontrivial的实体才会被合成于程序之中。决定一个拷贝构造函数是否为trivial的标准在于class是否展现出所谓的“bitwise copy semantics”。
Bitwise Copy Semantics(位逐次拷贝)
在下面的程序片段中：
#include "word.h"
Word noun("book");
void foo()
{
Word verb = noun;
//...
}
很明显verb是根据noun来初始化。但是在尚未看过Word类的声明之前，我们不可能预测这个初始化操作的程序行为。如果Word的设计者定义了一个拷贝构造函数，verb的初始化操作就会调用它。但是如果该类没有定义explicit copy constructor，那么是否会有一个编译器合成的实体被调用呢？这就得视该class是否展现“bitwise copy semantics”而定。举个例子，已知下面得class Word声明：
class Word{
public:
Word( const char * );
~Word(){ delete[] str; }
//...
private:
int cnt;
char *str;
};
这种情况下，并不需要合成一个缺省拷贝构造函数，因为上述声明展现了“default copy semantics”，而verb的初始化操作也就不需要以一个函数调用收场(当然，该类的定义存在着严重的缺陷)。然而，如果class object是这样声明：
class Word{
public:
Word( const String& );
~Word(){ }
//...
private:
int cnt;
String str;
};
其中String声明了一个explicit copy constructor：
class String{
public:
String( const char * );
String( const String & );
//...
};
在这个情况下，编译器必须合成一个拷贝构造函数以便调用member class string object的拷贝构造函数：
//C++伪码
Inline Word::Word( const Word& wd )
{
str.String::String(wd.str);
cnt = wd.cnt;
}
有一点需要特别注意：在这个被合成出来的拷贝构造函数中，如整数、指针、数组等等的nonclass members也都会被复制，正如我们所期待的一样。
不要Bitwise Copy Semantics！
什么时候一个类不展现“bitwise copy semantics”呢？有以下4种情况：
n 当类内含一个member object，而后者的class声明有一个拷贝构造函数时(不论是被类设计者明确地声明，或是被编译器合成的)
n 当类继承自一个基类而后者存在有一个拷贝构造函数时(再次强调，不论是被明确声明或是被合成而得)
n 当类声明了一个或多个虚函数时
n 当类派生自一个继承串链，其中有一个或多个虚基类时
前两种情况中，编译器必须将member或base class的“copy constructors调用操作”安插到被合成的拷贝构造函数中。后面两种情况较为复杂一些，接下来将详细地讨论。
重新设定虚表的指针
假设类声明了一个或多个虚函数，编译期间会进行程序扩张操作：
n 增加一个虚函数表，内含每一个有作用的虚函数的地址
n 将一个指向虚函数表的指针，安插在每一个类对象中
显然，如果编译器对于每一个新产生的类对象的vptr不能成功而正确地设好其初值，将导致错误的结果。因此，当编译器导入一个vptr到class中时，该class就不再展现bitwise semantics了。现在，编译器需要合成出一个copy constructor，以便将vptr适当地初始化，下面是个例子：
首先，定义两个类，ZooAnimal和Bear：
class ZooAnimal{
public:
ZooAnimal();
virtual ~ZooAnimal();
virtual void animate();
virtual void draw();
//...
private:
//ZooAnimal的animate()和draw()所需要的数据
}
class Bear : public ZooAnimal{
public:
Bear();
void animate(); //虽然没有明写virtual，它实际上也是virtual
void draw(); //虽然没有明写virtual，它实际上也是virtual
virtual void dance();
//....
private:
//ZooAnimal的animate()、draw()和dance()所需要的数据
}
ZooAnimal class object以另一个ZooAnimal class object作为初值，或Bear class object以另一个Bear class object作为初值，都可以直接靠“bitwise copy semantics”完成(除了可能会有的pointer member之外，为了简化，这里不考虑这种情况)。举例：
Bear yogi；
Bear winnie = yogi；
yogi会被default Bear consturctor初始化。而在构造函数中，yogi的vptr被设定指向Bear class的virtual table。因此，把yogi的vptr值拷贝给winnie的vptr是安全的。
当一个基类对象以其派生类的对象做初始化操作时，其vptr复制操作也必须保证安全，例如：
ZooAnimal franny = yogi；//这会发生切割(sliced)行为
franny的vptr不可以被设定为指向Bear class的virtual table。合成出来的ZooAnimal copy constructor会明确设定object的vptr指向ZooAnimal class的virtual table，而不是从右手边的class object中将其vptr现值拷贝过来。
处理Virtual Base Class Subobject
每一个编译器对虚拟继承的支持承诺，都表示必须让派生类对象中的virtual base class subobject位置在执行期就准备妥当。维护“位置的完整性”是编译器的责任。“bitwise copy semantics”可能会破坏这个位置，所以编译器必须在它自己合成出来的拷贝构造函数中做出仲裁。举个例子，在下面的声明中，ZooAnimal成为Raccoon的一个虚拟基类，同时RedPanda public继承自Raccoon：
class Raccoon : public virtual ZooAnimal{
public:
Raccoon(){}
Raccoon( int val ){}
//…
private:
//…
}
class RedPanda : public Raccoon{
public:
RedPanda(){}
RedPanda( int val ){}
//…
private:
//…
}
如果以一个Raccoon object作为另一个Raccoon object的初值，那么“bitwise copy”就绰绰有余了：
Raccoon rocky;
Raccoon little_critter = rocky;
然而如果企图以一个RedPanda object作为little_critter的初值，编译器必须判断“后续当程序员企图存取其ZooAnimal subobject时是否能够正确地执行”：
RedPanda rocky;
Raccoon little_critter = rocky;
在这种情况下，为了完成正确的little_critter初值设定，编译器必须合成一个拷贝构造函数，安插一些代码以设定virtual base class pointer/offset的初值，对每一个members执行必要的memberwise初始化操作，以及执行其它的内存相关操作。
参考资料：
《深度探索C++对象模型》P48~60
