每个派生类对象由派生类中定义的（非static）成员加上一个或多个基类子对象构成，因此，当构造、复制、赋值和撤销派生类型对象时，也会构造、复制、赋值和撤销这些基类子对象。
构造函数和复制控制成员不能继承，每个类定义自己的构造函数和复制控制成员。像任何类一样，如果类不定义自己的默认构造函数和复制控制成员，就将使用合成版本。
1：构造函数和继承
派生类的构造函数受继承关系的影响，每个派生类构造函数除了初始化自己的数据成员之外，还要初始化基类。
派生类的合成默认构造函数：除了初始化派生类的数据成员之外，它还初始化派生类对象的基类部分。基类部分由基类的默认构造函数初始化：
class father
{
public:
int publ_i;
father(int a=1, int b=2, int c=3):publ_i(a),priv_i(b), prot_i(c)
{
cout << "father constructor" << endl;
}
virtual void display()
{
cout << "[father]publ_i is " << publ_i << endl;
cout << "[father]priv_i is " << priv_i << endl;
cout << "[father]prot_i is " << prot_i << endl;
}
private:
int priv_i;
protected:
int prot_i;
};
class son: public father
{
public:
void display()
{
cout << "[son]publ_i is " << publ_i << endl;
cout << "[son]prot_i is " << prot_i << endl;
}
};
int main()
{
son ss1;
ss1.display();
}
执行”son ss1;”语句时，调用派生类son的合成的默认构造函数，该函数会首先调用基类的默认构造函数。上述代码的结果是：
father constructor [son]publ_i is 1 [son]prot_i is 3
如果派生类自己定义了构造函数，则该构造函数会隐式调用基类的默认构造函数：
class son: public father
{
public:
son(int a = 2):mypriv_i(a)
{
cout << "son constructor" << endl;
}
void display()
{
cout << "[son]publ_i is " << publ_i << endl;
cout << "[son]prot_i is " << prot_i << endl;
cout << "[son]mypriv_i is " << mypriv_i << endl;
}
private:
int mypriv_i;
};
int main()
{
son ss1;
ss1.display();
}
执行”son ss1;”语句时，调用派生类son的默认构造函数，该函数首先调用基类的默认构造函数初始化基类部分，然后，使用初始化列表初始化son::mypriv_i，最后，在执行son构造函数的函数体。上述代码的结果是：
father constructor son constructor [son]publ_i is 1 [son]prot_i is 3 [son]mypriv_i is 2
派生类构造函数还可以明确的在初始化列表中调用基类的构造函数，来间接的初始化基类成员。注意，在派生类列表中，不能直接初始化基类成员：
class son: public father
{
public:
son(int a = 2):mypriv_i(a),father(100)
{
cout << "son constructor" << endl;
}
void display()
{
cout << "[son]publ_i is " << publ_i << endl;
cout << "[son]prot_i is " << prot_i << endl;
cout << "[son]mypriv_i is " << mypriv_i << endl;
}
private:
int mypriv_i;
};
int main()
{
son ss1;
ss1.display();
}
不管初始化列表中的顺序如何，派生类构造函数，都是首先调用基类构造函数初始化基类成员，然后是根据派生类成员的声明顺序进行初始化。
如果尝试在初始化列表中直接初始化基类成员，会发生编译错误：
son(int a = 2):mypriv_i(a),publ_i(100)
{
cout << "son constructor" << endl;
}
报错如下：
test2.cpp: In constructor ‘son::son(int)’:
test2.cpp:29:29: error: class ‘son’ does not have any field named ‘publ_i’
son(int a = 2):mypriv_i(a),publ_i(100)
^
派生类构造函数不能初始化基类的成员且不应该对基类成员赋值。如果那些成员为 public 或 protected，派生构造函数可以在构造函数函数体中给基类成员赋值，但是，这样做会违反基类的接口。派生类应通过使用基类构造函数尊重基类的初始化意图，而不是在派生类构造函数函数体中对这些成员赋值。
注意，一个类只能初始化自己的直接基类。
2：复制控制和继承
派生类合成的复制控制函数，对对象的基类部分连同派生部分的成员一起进行复制、赋值或撤销，自动调用基类的复制构造函数、赋值操作符或析构函数对基类部分进行复制、赋值或撤销：
class father
{
public:
int publ_i;
father(int a=1, int b=2, int c=3):publ_i(a),priv_i(b), prot_i(c)
{
cout << "father constructor" << endl;
}
father(const father &src):publ_i(src.publ_i), priv_i(src.priv_i), prot_i(src.prot_i)
{
cout << "father copy constructor" << endl;
}
father& operator=(const father& src)
{
publ_i = src.publ_i;
priv_i = src.priv_i;
prot_i = src.prot_i;
cout << "father operator = " << endl;
return *this;
}
~father()
{
cout << "father destructor" << endl;
}
virtual void display()
{
cout << "[father]publ_i is " << publ_i << endl;
cout << "[father]priv_i is " << priv_i << endl;
cout << "[father]prot_i is " << prot_i << endl;
}
private:
int priv_i;
protected:
int prot_i;
};
class son: public father
{
public:
son(int a = 2):mypriv_i(a)
{
cout << "son constructor" << endl;
}
void display()
{
cout << "[son]publ_i is " << publ_i << endl;
cout << "[son]prot_i is " << prot_i << endl;
cout << "[son]mypriv_i is " << mypriv_i << endl;
}
private:
int mypriv_i;
};
int main()
{
son ss1(3);
son ss2(ss1);
ss2.display();
son ss3;
ss3 = ss1;
ss3.display();
}
“son ss2(ss1);”语句，将调用派生类son的合成的复制构造函数，该构造函数将会自动调用基类的复制构造函数；”ss3 = ss1;”语句，将调用派生类son的合成的赋值操作符函数，该函数会自动调用基类的赋值操作符函数；最后，程序退出之前，会将派生类son的三个对象进行析构，从而自动调用基类的析构函数；上述代码的结果如下：
father constructor son constructor father copy constructor [son]publ_i is 1 [son]prot_i is 3 [son]mypriv_i is 3 father constructor son constructor father operator = [son]publ_i is 1 [son]prot_i is 3 [son]mypriv_i is 3 father destructor father destructor father destructor
如果派生类自己定义了复制构造函数或赋值操作符，则应该显示的调用基类的复制构造函数或赋值操作符：
class father
{
public:
int publ_i;
father(int a=1, int b=2, int c=3):publ_i(a),priv_i(b), prot_i(c)
{
cout << "father constructor" << endl;
}
father(const father &src):publ_i(src.publ_i), priv_i(src.priv_i), prot_i(src.prot_i)
{
cout << "father copy constructor" << endl;
}
father& operator=(const father& src)
{
publ_i = src.publ_i;
priv_i = src.priv_i;
prot_i = src.prot_i;
cout << "father operator = " << endl;
return *this;
}
~father()
{
cout << "father destructor" << endl;
}
virtual void display()
{
cout << "[father]publ_i is " << publ_i << endl;
cout << "[father]priv_i is " << priv_i << endl;
cout << "[father]prot_i is " << prot_i << endl;
}
private:
int priv_i;
protected:
int prot_i;
};
class son: public father
{
public:
son(int a = 2):mypriv_i(a),father(100)
{
cout << "son constructor" << endl;
}
son(const son& src):mypriv_i(src.mypriv_i),father(src)
{
cout << "son copy constructor" << endl;
}
son& operator=(const son& src)
{
father::operator=(src);
mypriv_i = src.mypriv_i;
cout << "son operator = " << endl;
return *this;
}
void display()
{
cout << "[son]publ_i is " << publ_i << endl;
cout << "[son]prot_i is " << prot_i << endl;
cout << "[son]mypriv_i is " << mypriv_i << endl;
}
private:
int mypriv_i;
};
int main()
{
son ss1(3);
son ss2(ss1);
ss2.display();
son ss3;
ss3 = ss1;
ss3.display();
}
在派生类son的复制构造函数中，初始化列表中显示调用基类复制构造函数使用src初始化基类部分。这里如果省略调用基类复制构造函数的调用的话，编译器会自动调用基类的默认构造函数初始化基类部分，这就造成新构造的对象会有比较奇怪的配置，它的基类部分保存默认值，而他的派生类部分是src的副本；
在派生类son的赋值操作符函数中，显示调用了基类的赋值操作符函数。如果省略了这一调用，则赋值操作，仅仅使该对象的mypriv_i与src的mypriv_i相同；
上述代码的结果如下：
father constructor son constructor father copy constructor son copy constructor [son]publ_i is 100 [son]prot_i is 3 [son]mypriv_i is 3 father constructor son constructor father operator = son operator = [son]publ_i is 100 [son]prot_i is 3 [son]mypriv_i is 3 father destructor father destructor father destructor
如果定义了派生类的析构函数，则不同于复制构造函数和赋值操作符：编译器会自动调用基类的析构函数，因此在派生类的析构函数中，只负责清除自己的成员：
~son()
{
cout << "son destructor" << endl;
}
定义了son的析构函数之后，上述代码的结果是：
... son destructor father destructor son destructor father destructor son destructor father destructor
对象的撤销顺序与构造顺序相反：首先运行派生析构函数，然后按继承层次依次向上调用各基类析构函数。
另外，如果基类指针指向了一个派生类对象，则删除该基类指针时，如果基类的析构函数不是虚函数的话，则只会调用基类的析构函数，而不会调用派生类析构函数。比如还是上面的father和son两个类，运行下面的代码：
father *fp = new son;
delete fp;
结果就是：
father constructor son constructor father destructor
为了避免这种情况的发生，应该将基类的析构函数定义为虚函数，这样，无论派生类显式定义析构函数还是使用合成析构函数，派生类析构函数都是虚函数。从而可以得到正确的结果。
因此，即使析构函数没有工作要做，继承层次的根类也应该定义一个虚析构函数。
3：构造函数或析构函数中调用虚函数
在运行构造函数或析构函数的时候，对象都是不完整的。为了适应这种不完整，编译器将对象的类型视为在构造或析构期间发生了变化。在基类构造函数或析构函数中，将派生类对象当作基类类型对象对待。
因此，如果是在构造函数或析构函数中调用虚函数，则运行的是为构造函数或析构函数自身类型定义的版本。如果在基类构造函数中调用虚函数，则构造派生类的时候，该虚函数实际上还是调用的基类的版本：
class father
{
public:
int publ_i;
father(int a=1, int b=2, int c=3):publ_i(a),priv_i(b), prot_i(c)
{
cout << "father constructor" << endl;
display();
}
virtual void display()
{
cout << "[father]publ_i is " << publ_i << endl;
cout << "[father]priv_i is " << priv_i << endl;
cout << "[father]prot_i is " << prot_i << endl;
}
private:
int priv_i;
protected:
int prot_i;
};
class son: public father
{
public:
son()
{
cout << "son constructor" << endl;
}
void display()
{
cout << "[son]publ_i is " << publ_i << endl;
cout << "[son]prot_i is " << prot_i << endl;
}
};
int main()
{
father *fp = new son;
}
在构造son对象时，需要调用father的构造函数，在father的构造函数中调用了虚函数display。此时，虽然构造的是派生类对象，但是这里依然还是调用基类的display函数。因此，上述代码的结果为：
father constructor [father]publ_i is 1 [father]priv_i is 2 [father]prot_i is 3 son constructor
无论由构造函数（或析构函数）直接调用虚函数，或者从构造函数（或析构函数）所调用的函数间接调用虚函数，都应用这种绑定。
要理解这种行为，考虑如果从基类构造函数（或析构函数）调用虚函数的派生类版本会怎么样。虚函数的派生类版本很可能会访问派生类对象的成员，但是，对象的派生部分的成员不会在基类构造函数运行期间初始化，实际上，如果允许这样的访问，程序很可能会崩溃。