继承

1、具有继承基类的类创建实例时构造和析构的顺序：父类构造->子类构造->子类析构->父类析构

2、继承方式：

• 公有继承：class A:public B
• 保护继承：class A:protected B
• 私有继承：class A:private B

3、覆盖和隐藏

隐藏：

• 子类通过重写父类的同名函数，以达到隐藏父类同名函数的效果；当然，我们继承父类，父类中同名函数仍旧被继承过来的，可以通过super.XXX来访问父类中被隐藏的同函数；三个关键字：父子关系、同名函数、隐藏
• 子类的实例对象调用父类被隐藏的同名函数：实例对象名.父类名::同名函数
• 当子类中有同名不同参数的函数时，子类的实例对象是不能够直接调用父类中的同名函数的，只能够进行隐藏
• 当子类有同名数据成员，同样是做隐藏，要想在子类中访问到父类的同名数据成员，我们需要使用父类名::数据成员名

is-a:

• 基类和派生类的一种关系（车是基类，自行车是派生类，此时自行车is-a车，即自行车是车的一种）
• 可以将一个派生类的对象赋给一个基类对象，但是不能够反过来

int main(){
Soldier s1;
Person p1 = s1;
Person *p2 = &s1;

s1 = p1;//非法的
Soldier *s2 = &p1;//非法的
return 0;
}

• 一个被调用函数的参数可以传入对于的基类或子类对象，很灵活

fun1(Person &p){
...
}

fun2(Person *p){
...
}
int main(){
Person p1;
Soldier s1;
fun1(p1),fun2(&p1);
fun1(s1),fun2(&s1);
return 0;
}

• 存储结构：用子类对象初始化父类对象的情况，此时子类对象会退化，父类对象是不能够访问到子类对象特有的成员的；当用子类对象初始化父类指针时，也是一样的

 4.多继承和多重继承

• 多重继承：子类和直接父类或间接父类保持is-a的关系

 

• 多继承：

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;

/**
 * 定义工人类: Worker
 * 数据成员: m_strName
 * 成员函数: work()
 */
class Worker
{
public:
    Worker(string name)
    {
        m_strName = name;
        cout << "Worker" << endl;
    }
    ~Worker()
    {
        cout << "~Worker" << endl;
    }
    void work()
    {
        cout << m_strName << endl;
        cout << "work" << endl;
    }
protected:
    string m_strName;
};

/**
 * 定义儿童类: Children
 * 数据成员: m_iAge
 * 成员函数: play()
 */
class Children
{
public:
    Children(int age)
    {
        m_iAge = age;
        cout << "Children" << endl;
    }    
    ~Children()
    {
        cout << "~Children" << endl;
    }    
    void play()
    {
        cout << m_iAge << endl;
        cout << "play" << endl;
    }
protected:
    int m_iAge;
};

/**
 * 定义童工类: ChildLabourer
 * 公有继承工人类和儿童类
 */
class ChildLabourer : public Worker,public Children
{
public:
    ChildLabourer(string name, int age):Worker(name),Children(age)
    {
        cout << "ChildLabourer" << endl;
    }

    ~ChildLabourer()
    {
        cout << "~ChildLabourer" << endl;
    }    
};

int main(void)
{
    // 使用new关键字创建童工类对象
    ChildLabourer *childLabourer = new  ChildLabourer("haha",8);
    // 通过童工对象调用父类的work()和play()方法
    childLabourer->work();
    childLabourer->play();
    // 释放
    delete childLabourer;
    childLabourer=NULL;
    return 0;
}

 

5.虚继承

• 问题引入：菱形继承的困扰，导致A类被构造出多个，系统产生了必要的开销；如何解决这种问题，我们需要用到虚拟继承，保证基类中的数据只保留一份，基类无法保存从子类传入的数据，只是使用默认的参数
• 关键字：virtual

#include <iostream>
#include <stdlib.h>
#include <string>
using namespace std;

/**
 * 定义人类: Person
 */
class Person
{
public:
    Person()
    {
        cout << "Person" << endl;
    }
    ~Person()
    {
        cout << "~Person" << endl;
    }
    void eat()
    {
        cout << "eat" << endl;
    }

};

/**
 * 定义工人类: Worker
 * 虚继承人类
 */
class Worker : virtual public Person
{
public:
    Worker(string name)
    {
        m_strName = name;
        cout << "Worker" << endl;
    }
    ~Worker()
    {
        cout << "~Worker" << endl;
    }
    void work()
    {
        cout << m_strName << endl;
        cout << "work" << endl;
    }
protected:
    string m_strName;
};

/**
 * 定义儿童类:Children
 * 虚继承人类
 */
class Children : virtual public Person
{
public:
    Children(int age)
    {
        m_iAge = age;
        cout << "Children" << endl;
    }    
    ~Children()
    {
        cout << "~Children" << endl;
    }    
    void play()
    {
        cout << m_iAge << endl;
        cout << "play" << endl;
    }
protected:
    int m_iAge;
};

/**
 * 定义童工类：ChildLabourer
 * 公有继承工人类和儿童类
 */
class ChildLabourer:public Worker,public Children
{
public:
    ChildLabourer(string name, int age):Worker(name),Children(age)
    {
        cout << "ChildLabourer" << endl;
    }

    ~ChildLabourer()
    {
        cout << "~ChildLabourer" << endl;
    }    
};

int main(void)
{
    // 用new关键字实例化童工类对象
    ChildLabourer *p = new ChildLabourer("haha",8);
    // 调用童工类对象各方法。
    p->eat();
    p->work();
    p->play();
    delete p;
    p = NULL;

    return 0;
}
/*结果：Person
Worker
Children
ChildLabourer
eat
haha
work
8
play
~ChildLabourer
~Children
~Worker
~Person*/