C++ 面向对象的三个特点--继承与封装（二）

顺着上一篇的内容，我们继续来了解继承的基本知识。

• 派生类的构造函数和析构函数

派生类继承了基类的成员，但是不能继承基类的构造函数和析构函数，首先，我们了解构造函数和析构函数的执行顺序是当我们创建一个派生类的对象是，先执行的是基类的构造函数，然后是派生类的构造函数。析构函数则正好相反，先执行派生类的析构函数，再执行基类的析构函数。

• 派生类构造函数和析构函数的构造规则

当基类的构造函数没有参数的时，或者没有显示的定义构造函数时，派生类可以不向基类传递参数，甚至可以不定义构造函数。但是当基类带有含参数的构造函数的时候，派生类必须定义构造函数，以提供把参数传递给基类构造函数的途径。

派生类构造函数的定义格式：

派生类名(参数总表) : 基类名(参数表)

其中基类的构造函数参数通常来源于派生类构造函数的参数总表，也可以设置为常数值。

例：

base:

base(int n)

derived:

derived(int n) : base(n)

或derived() : base(1)

还需注意的几点：

1）.如果派生类的基类也是一个派生类，每个派生类只需负责他的直接基类的构造，依次上溯。

2）.因为析构函数是不带参数的，在派生类中是否要定义析构函数与它所属的基类无关，它们是各自独立的。

3）.派生类中含有内嵌对象成员时，构造函数的一般形式如下：派生类名（参数总表）：基类名（参数表），内嵌对象名1（参数表），····，内嵌对象名n（参数表），此时构造函数的执行顺序是基类的构造函数，内嵌对象成员的构造函数（调用顺序按照声明顺序），派生类的构造函数。

EX:

// 基类
class Base
{
public:
    Base(){a = 0;b = 0;}
    Base(int x,int y)
    {
       a = x;
       b = y;
    }
    virtual ~Base(void);

    void print()
    {
       printf("\na = %d b = %d", a, b);
    }

private:
    int a,b;
};

// 派生类
class Derivel :
    private Base
{
public:
    Derivel():Base(1, 1)
    {
       c = 0;
       d = 0;
    }

    Derivel(int x, int y):Base(x + 1, y + 1)
    {
       c = x;
       d = y;
    }

    Derivel(int x, int y, int m, int n):Base(m, n)
    {
       c = x;
       d = y;
    }
    virtual ~Derivel(void);

    void print()
    {
       Base::print();
       printf(" c = %d d = %d", c, d);
    }
private:
    int c,d;
};

// main
int _tmain(int argc, _TCHAR* argv[])
{
    Base obj;
    obj.print();

    Derivel obj1;
    obj1.print();

    Derivel obj2(10,10);
    obj2.print();

    Derivel obj3(10,10,20,20);
    obj3.print();

    system("pause");
    return 0;
}

输出结果：

a = 0 b = 0

a = 1 b = 1 c = 0 d = 0

a = 11 b = 11 c = 10 d = 10

a = 20 b = 20 c = 10 d = 10

• 多重继承和多重继承的构造函数

声明两个及两个以上的基类的派生类称为多重继承。其声明格式一般如下：

Class 派生类名：继承方式1 基类名1，继承方式2 基类名2{

}；

注意：当没有写明继承方式的时候按照默认的继承方式认定，默认的继承方式是private。

多重继承中，三种继承方式对于基类成员在派生类中的访问性的规则和单继承是一样的。

多重继承的构造函数的执行顺序与单继承构造函数的执行顺序相同，也是遵循先执行基类中的构造函数，在执行对象成员的构造函数，最后执行派生类的构造函数的原则。在各个基类之间，则严格按照派生类的声明顺序从左到右依次执行。而析构函数的话则是相反的。

EX：

// 基类1
class Base
{
public:
    Base()
    {
       printf("Constructor base.\n");
    }

    virtual ~Base()
    {
       printf("Destructor base.\n");
    }
};

// 基类2
class Base1
{
public:
    Base1()
    {
       printf("Constructor base1.\n");
    }

    ~Base1()
    {
       printf("Destructor base1.\n");
    }
};

// 派生类
class Derivel :
    private Base,Base1
{
public:
    Derivel()
    {
       printf("Constructor derivel.\n");
    }

    virtual ~Derivel()
    {
       printf("Destructor derivel.\n");
    }
};

// main
int _tmain(int argc, _TCHAR* argv[])
{
    Derivel *a = new Derivel();
    delete a;

    system("pause");
    return 0;
}

输出结果：

Constructor base.

Constructor base1.

Constructor derivel.

Destructor derivel.

Destructor base1.

Destructor base.