笔记：关于C++继承

1.单继承

继承权限
C++继承中包含三种继承方式：public protected private
继承方式代表父类中的属性在子类中最低权限
例：若子类继承方式是protected，子类从父类中继承的public属性都将转为protected属性；若子类继承方式是private，子类从父类中继承的public属性和 protecte属性都将转为private属性；

class Father
{
   public:
   Father(string name,int age) :name(name),age(age){}
   void print()
   {
       cout<<"father:"<<name<<age<<endl;
   }
   protected:
   string name;
   int age;
};
class Son:protected Father
{
   public:
   Son(string name,int age):Father(name,age){}
   void print_son()
   {
      cout<<"son:"<<name<<age<<endl;
   }
   protected:
   //继承的属性
   //name
   //age
   //print()
};
int main()
{
    Son myson("张三",18);
    myson.print_son();//可以输出因为继承了父类name和age属性
    myson.print()//报错 因为print()继承为protected属性无法外部调用，解决办法：改为public继承
}

构造函数与析构函数
子类构造函数必须调用父类构造函数，在子类运行构造函数之前先运行父类构造函数；
在终结对象时，先析构子类再析构父类

class Father
{
   public:
   Father(string name,int age) :name(name),age(age)
   {
      cout<<"Fatherget!";
   }
   ~Father()
   {
      cout<<"Fatherout!";
   }
   void print()
   {
       cout<<"father:"<<name<<age<<endl;
   }
   protected:
   string name;
   int age;
};
class Son:protected Father
{
   public:
   //构造子类时必须调用父类构造函数为继承来的属性赋初值
   Son(string name,int age,string girlfriend_name):Father(name,age),girlfriend_name(girlfriend_name)
   {
        cout<<"Songet!";
   }
   ~Son()
   {
      cout<<"Sonout!";
   }
   void print_son()
   {
      cout<<"son:"<<name<<age<<endl;
   }
   protected:
   string girlfriend_name;
};
int main()
{
    {Son myson("张三",18,"小芳");}
    //输出结果：Fatherget!Songet!Sonout!Fatherout!
}

2.多继承

多继承指子类有两个或两个以上父类
多继承继承权限与构造函数写法与单继承相同

3.菱形继承

多继承中，当一个子类继承的两个或多个父类是继承于同一个祖父类，多个父类会继承至少一个相同属性，子类在构造函数初始化时会存在二义性，所以该子类的构造函数应调用祖父类的构造函数。

class A
{
   public:
   int a;
   A(int a):a(a){}
};
class B:public A
{
   public:
   B(int a):A(a){}
};
class C:public A
{
   public:
   C(int a):A(a){}
};
class D:public B,public C
{
   public:
   C(int a):A(a){}//调用祖父A的构造函数
   D(int a):B(a),C(a)//错误，产生二义性
};

虚函数：用virtual修饰的函数称为虚函数，构造函数没有虚函数，析构函数有虚函数。
虚函数表：用来操作虚函数的函数指针。

虚函数对于类的内存影响：
一个空的类占用1个字节，作为内存标记，但多个虚函数在类中始终只占8个字节（32位4个字节）。

纯虚函数：
没有函数体的函数

virtual test(int element) = 0;

抽象类：
具有至少一个纯虚函数的类，抽象类不能创建对象，但是可以创建对象指针。
ADT：abstract data type 抽象数据类型

class School
{
    public:
         virtual int student(int name) = 0;
         virtual string student_sexual(string x) = 0;
         virtual void print_student() = 0;
};

int main()
{
    School s;//报错无法构建对象，因为类School是抽象类
}

若子类继承的父类是抽象类，那么子类想要用父类中的虚函数，必须重写。

class School
{
    public:
         virtual int student(int name) = 0;
         virtual string student_sexual(string x) = 0;
         virtual void print_student() = 0;
};
class grade1:public School
{
};
class grade2:public School
{
    int student(int name) 
    {
        return 0;
    }
    string student_sexual(string x) 
    {
        return x;   
    }
    void print_student() {}
};
int main()
{
    grade1 g;//报错无法构建对象，因为继承的虚函数没重写。
    grade2 g;//可以构建，所有继承的虚函数都重写的函数体。
}

虚析构函数：
父类指针被子类对象初始化时析构会出现问题，子类对象析构时只调用父类析构函数，并不会调用子类析构函数，需要将父类析构函数写为虚函数。

class A
{
  public:
   ~A()
   {
      cout << "父类析构函数"<<endl;
   }
};
class B:public A
{
  public:
     ~B()
     {
        cout << "子类析构函数"<<endl;
     }
};

int main()
{
   {
      A* pA = new B;//父类指针被子类对象初始化 
      delete pA;
   }
   //输出：父类析构函数
}

class A
{
public:
    virtual ~A()
    {
        cout << "父类析构函数" << endl;
    }
};
class B :public A
{
public:
    ~B()
    {
        cout << "子类析构函数" << endl;
    }
};

int main()
{
    {
        A* pA = new B;//父类指针被子类对象初始化 
        delete pA;
    }
    //输出：父类析构函数
    //     子类析构函数
}

原因是：当定义一个指向子类实例的父类指针的时候，内存中实例化了子类，由于子类继承了父类,因此内存中的子类里包含父类的所有成员。但由于申明的是父类指针，因此该指针不能够访问子类的成员，而只能访问父类的成员。然而在父类里可以声明纯虚函数和定义虚函数，使用父类指针访问虚函数或纯虚函数的时候，访问到的是子类里重写的函数。当然，对于虚函数，如果子类里没有对其重写的话，仍然访问到父类里定义的虚函数。可见虚函数和纯虚函数的却别仅仅在于：纯虚函数没有定义,只有声明。
解释来源

4.虚函数与继承

继承同名问题：
1.正常的对象的访问和正常指针的访问，用的什么类就用用什么的成员函数。

class A
{
   public:
        void print()
        { cout << "A"; }
};
class B:public A
{
   public:
       void print()
       { cout << "B" ; }
};
int main()
{
   A a;
   A* pA = new A;
   a.print();
   pA->print();
   B b;
   B* pB = new B;
   b.print();
   pB->print();
   //输出  AABB
}

2.不正常情况
（1）父类指针被子类初始化：当父类指针被子类初始化，并且父类与子类有同名函数时，调用哪个函数看指针类型。

int mian()
{
    A* pA = new B;
    pA->print();
    //指针类型是A类所以调用的A类的print(),输出A
}

（2）virtual情况下（有虚函数情况下）：父类中存在虚函数，调用时看对象。

class A
{
   public:
       virtual void print()
        { cout << "A"; }
};
class B:public A
{
   public:
       void print()
       { cout << "B" ; }
};
int main()
{
    A* pA = new B;
    pA->print();
    delete pA;
    B* pB = new B;
    pB->print();
    delete pB;
    B b;
    b.print();
    //输出:BBB
}

（3）父类中的同名函数也是继承于祖父类的虚函数：遵从上一条规则。

class A
{
public:
   virtual void print()
    {
        cout << "A";
    }
};
class B :public A
{
public:
    void print()
    {
        cout << "B";
    }
};
class C :public B
{
 public:
    void print()
    {
        cout << "C";
    }
};
int main()
{
    B* pC = new C;
    pC->print();
    C c;
    c.print();
    //输出结果：CC
}