继承 (inherit )的使用与注意事项

重点提示：并不是父类构造函数先执行再到子类的构造函数执行，而是子类的析构函数先执行,在子类的析构函数里再调用父类的析构函数。

1. 继承其实就是在一个类的基础上扩展新的功能的类型。

#include <iostream>

using namespace std ;

class Animal {

private:

int age;

public:

void eat() {

age = 88;

cout << "animal eat" << endl;

};

};

// Animal 叫作 Human 的父类 , Human 是 Animal 的子类

// 继承是可以多层继承的, 基类是最底层的类。 子类的子类以下级别的类叫派生类 .

class Human : public Animal { // Human 继承了 Animal, 完全具有 Animal 类对象的功能

public:

void think() { // 扩展的功能

cout << "human think" << endl;

}

};

int main(void)

{

Human h;

h.eat();

h.think();

return 0;

}
注意:

1).继承时,父类的私有成员也是有继承过来的,只是子类不能直接访问父类的私有成员

2)一个对象 / 类型的大小,只算属性成员的大小,函数成员不算大小的。 同时也需注意它的祖先类的大小。

3)创建一个子类对象时,父类也需创建一个对象 , 子类对象是由父类对象与它自己的属性成员组合成的 .

4)友员的关系没有继承的

public 继承时 :

父类的公有成员在子类里的权限还是 public 的

父类的受保护成员在子类里的权限还是 protected 的

父类的私有成员在子类里不能直接访问

protected 继承 :

父类的公有成员在子类里的权限是 protected 的

父类的受保护成员在子类里的权限还是 protected 的

父类的私有成员在子类里不能直接访问private 继承 :

父类的公有成员在子类里的权限是 private 的

父类的受保护成员在子类里的权限是 private 的
父类的私有成员在子类里不能直接访问

可简化成以下表格：

继承方式\成员类型 public             protected     private

public                       public             protected     无法继承

protected                 protected       protected     无法继承

private                      private            private          无法继承

2. 继承时,创建子类对象时也会创建它的父类对象。子类和父类的构造函数都会触发 .

#include <iostream>

using namespace std;

class Animal {

public:

Animal() {

cout << "animal init " << endl;

}

~Animal() {

cout << "animal exit " << endl;

}

};

class Human : public Animal {

public:

Human() {

cout << "human init " << endl;

}

~Human() {

cout << "human exit " << endl;

}

};

int main(void)

{

Human *h;

h = new Human;

cout << "#################" << endl;

delete h;

return 0;

}

编译执行时的输出:

[root@localhost 11inherit]# ./a.out

animal init

human init

#################human exit

animal exit

从表面上看当创建对象时,父类构造先执行,然后才是子类的构造函数执行。

反汇编来看,可以发现其实是子类的构造函数先执行,在子类的构造函数里再调父类的构造函数 .

子类的析构函数先执行,在子类的析构函数里再调用父类的析构函数 .

当父类的构造函数必须传参数时 , 必须在子类的构造函数的函数体加上” : 父类构造函数名 ( 参数 )” 来调用父类

的构造函数 .

class Animal {

private:

int num;

public:

Animal(int num) {

this->num = num;

cout << "animal init num = " << num << endl;

}

~Animal() {

cout << "animal exit " << endl;

}

};

class Human : public Animal {

private:

int hh;

public:

Human(int num, int n) : hh(n), Animal(num){

cout << "human init hh = " << hh << endl;

}

~Human() {

cout << "human exit " << endl;

}

};

int main(void)

{

Human *h;

h = new Human(123, 7788);

cout << "#################" << endl;

delete h;

return 0;

}

构造函数的” :” 可以调用父类的构造函数 ( 只能调用父类的构造函数, 不能越级 ), 也可以用于内部属性成员进

行初始化 .3. 多重继承

通过继承多个父类扩展出一个新的类型。

class AA {

...

};

class BB {

..

};

class AB : public AA, public BB {

...

};

多重继承也会带来新的问题,如下代码:

// 基类

class Object {

public:

Object() {

cout << "object init" << endl;

}

};

class A : public Object {

// 当创建 A 的对象时, Object 也需创建一个对象

};

class B : public Object {

// 当创建 B 的对象时, Object 也需创建一个对象

};

class AB : public A, public B {

// 创建 AB 的对象时, A 和 B 都需要创建一个对象 , 但会有两个 Object 对象

};

int main(void)

{

AB a;

return 0;

}

要解决重复创建同一基类的对象时,可以使用虚继承 .

Class A : virtual public Object {

};Class B : virtual public Object {
};