Inheritance继承

Employee 父
Manager 子

public继承 维持不变 权限不变 可以转换为子类

//派生类可以向基类转换，但是会丢失派生类的特性
 //反之，基类不可向派生类转换     对象切割，以public
 //protected 和private 需使用强制转换
 pa=reinterpret_cast<A*>(pb)//很危险！！！！！！！！！

protected继承 修改访问权限，全部变成protected
将基类中的public变成protected
private继承 全部变成private，将基类中public，protected改为private

构造函数和析构函数不能被继承
子类构造必须要显式构造父类

Manager(const Manager& other):Employee(other)//拷贝构造

派生类也可作为基类

class Base
{
public:             //外部可以访问
    int public_i_;
protected:          //内部可以访问，可继承子类可访问
    int protected_i_;
private:            //类内部可访问            不可继承，子类不可访问
    int private_i_;
};

class A:public Base;
Class B:protected Base;
class C:private Base;

class AA:public B{//可以访问public_i_;};
//外部不可

class AA :public C
{
    //Base::public_i_;  //不可以 被private截断
};

---

先构造父类，再子类
先析构子类，再父类
默认调用默认父类的构造函数，如果父类中没有默认的构造函数，须在初始化列表中显式的构造(A()base(0))

与父类相同函数名，会重写，将父类的方法重写，父类中的方法就不存在了

A a;
Base *p_base=&a;//只能够父类指针子类指针，子类指针不可指向父类指针
p_base.GetNum();//调用的是父类的方法
//如果父类当中是虚函数，virtual GetNum()，会调用子类方法

Base *p_a=new B();//虚析构，只调用a，没调用b

父类实现虚函数，从子类当中寻找最符合的方式，比较符合实际情况

---

base String
A MyString

String 
{
public:String(char *str="")
~String(){delete[]str_;}
protected:
    char *str_;}；
MyString:public String
{
MyString(char *str="");
~MyString(){delete[]str_}
};

MyString str;//被构造了两次，却只析构了一次

MyString(char *str=""):String(str);//直接调用父类的构造函数,析构子类，析构父类，出错

~String();//应该由父类的析构函数来 回收
由父类继承来的东西，不要在此类当中进行显式的操作！！！！！！！！
由谁创建的变量就由谁来管理！！！！！！！！

MyString str(“I Love”);
String *p_string=&str;
str+”Mark”;//调用子类的+
*pString+”Mark”//调用父类的+
//把父类的+做成虚函数，此时*pString+”Mark”调用子类的+

---

继承的体系
父类的构造 父类成员的构造 子类构造
子类析构 父类成员的析构 父类析构

---

虚继承
多重继承
class A;有 int a
class B:public A;有int b
class C:public A;有int c
class D:public B, public C//菱形继承
{
//有2个a，一个b和一个c
}
D.a访问不明确（b的a或C的a？）
D d;
d.C::a;//明确a是哪个
d.B::a;

虚继承
class B:virtual public A;
class C:virtual public A;
class D:virtual public B,virtual Public C;
此时，只有一个a

---

纯虚函数，无法被实例化，需要子类强制性实现
抽象类要用纯虚函数，不能创建对象，是其它类的基类，接口的作用

class Animal
{
public:
    virtual void Cry()=0;//纯虚函数，无须实现，需要子类来实现
};
class Dog:public Animal
{
public:
};

---

构造函数不会被继承，初始化列表是初始化自己的，父类的变量不能在初始化类表初始化

Manager(const String&name,const int lev,const int salapy_base=5000):Employee(name,lev/*父类变量*/),salapy_base_(salapy_base_),employees_(nummptr)/*子类变量*/{}//这样,由于父类的在父类初始化属于自己的，用自己的方式初始化
ls.Employee::salapy_base_;//父
ls.salapy_base_;//子

数据的重定义并非覆盖，而是你有一个我也有一个（名字相同而已）

---

函数
只要函数名相同，就会构成重载
overload 重载 作用域相同情况下
overwrite 重写 只要函数名相同就构成重定义
overread （虚函数）覆盖

---

hsa-a 新类当中使用了某类来实现一些功能 组合
is-a 新类当中继承类某类 来扩展一些功能 继承