私有继承特性

保护继承特性

公有继承特性

通过宏定义解决重定义

在被继承的类的.h中：

#ifndef PERSON_H  //只要后面的名字能区分于其他文件即可
#define PERSON_H
//代码段
#endif

【菱形继承】B和C都继承A，而D继承了B和C

虚继承virtual

class Worker:virtual public Person{};
class Farmer:virtual public Person{};
class MigrantWorker:public Worker,public Farmer{};//农民工这个类中只含有一份Person的数据

【多重继承】：步兵类继承了士兵类，士兵类继承了人类

【多继承】：A继承了B，也继承了C（比如农民工类继承了农民类也继承了工人类），一个子类同时有两个父类，继承方式要写上（public/private/protected?），如果不写则系统默认为private

class MigrantWorker:public Worker,public Farmer{...};

void test1(Person p){...}
void test2(Person &p){...}
void test3(Person *p){...}
int main(){
    Person p;
    Soldier s;
    test1(p);
    test1(s);//使用test1方法时，这两种都会产生一个临时变量（临时实例化的p），调用后会销毁这个临时变量
    //使用test2和test3都不会产生临时变量，效率更高
}

Person *p=new Soldier;//用父类Person的指针指向堆中分配的子类Soldier的对象
delete p;
p=NULL;//只执行父类的析构函数，而不执行子类的析构函数，可能导致内存泄露

【如何在这种情况下防止内存泄露？】

虚析构函数：当存在继承关系，且要用一个父类的指针指向堆中子类的对象，并希望用父类的指针释放这块内存时，可以使用。

class Person{
    Person();
    virtual~Person();  //前面加关键字virtual即可，这个关键字可以被继承下去
}
//在Soldier.h中，即使在~Soldier前面不写virtual，也相当于有了这个关键字（被继承下来了）

派生类的对象可以赋值的基类，而基类的对象不能赋值给派生类

Soldier s1;
Person p1=s1;
Person *p2=&s1;//这三行是正确的

s1=p1;
Soldier *s2=&p1;//这两行是错误的

对于作为函数参数时：

void fun(Person *p){...}
int main(){
    Person p1;
    Soldier s1;
    fun(&p1);
    fun(&s1);//这两种都是正确的
}

用子类对象初始化父类对象时，从父类中继承下来的属性会被初始化，而子类中特有的属性则会被截断（不会赋值给父类）

子类和父类中的同名函数不能进行重载，只能进行隐藏

父类中：void ABC();

子类中：void ABC();

子类中的ABC函数会隐藏掉父类中的ABC函数，【子类中的对象】实例化后只能直接访问子类中的ABC函数

（不局限于成员函数，数据成员也有同名隐藏）

Soldier so;  //实例化一个子类的对象
so.play();  //调用的是子类中的play
so.Soldier::play();  //可以通过这种方式调用父类中的paly
//数据成员的访问也同理

※保护继承：

【protected】和【public】成员都会继承到【子类】的【protected】下

【private】继承后仍然无法直接访问

※私有继承：

【protected】和【public】成员都会继承到【子类】的【private】下

【private】继承后仍然无法直接访问

【继承方式】

1、共有继承 class A：public B

2、保护继承 class A：protected B（protected在不涉及继承时，跟private一样）

3、私有继承 class A：private B

————————————————————————————

※共有继承：

class Person{
public:
    void eat();
protected:
    int m_iAge;
private:
    string m_strName;
};
void Person::eat(){
    m_strName="Jim";
    m_iAge=10;
    cout<<m_strName<<m_iAge<<endl;  //可以正常访问
}
int main(){
    Person per;
    cout<<per.m_iAge<<endl;  //不能访问，因为m_iAge是private类型（protected类型也不行）
    per.eat();  //可以通过成员函数eat打印出m_iAge，因为eat是public类型
}

【protected】下的数据成员也会继承到子类的【protected】类型下面

【private】下的数据成员继承到子类的【不可见位置】而非【private】类型下面，无法访问

要实例化一个派生类，必先实例化一个基类，销毁时先执行基类的析构函数，再执行派生类的析构函数

具有包含关系，比如【工人类】是【人类】的子集

class Worker:public Person  //对Person这个类的继承，Worker也拥有了Person的属性
{
public:
    void work();
    int m_iSalary();
}

此时称【Worker】是【Person】的派生类/子类，【Person】是【Worker】的基类/父类