1.引入继承

学生管理系统

学生

老师

社管阿姨

保安大叔

4个类 4个类有很多重复的东西

name age telephone ...等

继承 Person->老师学生等

从这里我们可以看到继承目的:类之间的复用

2.继承

1°定义

class Student(派生类):public(继承方式) Person(基类)

{};

2°访问方式

#include <iostream>
using namespace std;

class Person
{
public:
    void Print()
    {
        cout << "name:" << _name << endl;
        cout << "age:" << _age << endl;
    }
protected:
    string _name = "peter";//姓名
    int _age = 18;//年龄
};

//继承
//private和protected在当前类无差别
//在继承的子类有差别 
//继承下来的private不可用 protected可以用
//谁的范围小就取谁
//public>protected>private
//实际当中都用public继承 几乎不使用protected/private
class Student :public Person
{
protected:
    int _stuid;//学号
};

class Teacher :public Person
{
protected:
    int _jobid;//工号
};

int main()
{
    Student s;
    Teacher t;
    s.Print();
    t.Print();
    return 0; 
}

3.切片

派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用->切片
而基类对象不能赋值给派生类对象范围大的可以给范围小的
基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针是指

向派生类对象时才是安全的

class Person
{
protected:
    string _name; //姓名
    string _sex;  //性别	
    int _age;	  //年龄
};

class Student :public Person
{
public:
    int _No;//学号
};

int main()
{
    Person p;
    Student s;

    //子类和父类之间的赋值兼容规则
    //1.子类对象可以赋值给父亲对象/指针/引用
    p = s;
    Person* ptr = &s;
    Person& ret = s;
    //切片
    //自己的_No不给 其他继承的可以赋值
    //指针和别名也是 只会有部分的指针和别名
    //2.反过来行不行?
    //s=p;绝对不行
    //3.Student* sptr=(Student*)ptr;
    //有可能可以 这个父类的指针指向子类对象v 
    return 0;

4.继承中的作用域

就近:如果两个变量是一样的不会报错先找自己类里的变量再找父类里的变量

如果就想访问父类的同名变量的话加上Person::进行限定

class Person
{
protected:
    string _name = "小李子"; // 姓名
    int _num = 111; // 身份证号
};
class Student : public Person
{
public:
    void Print()
    {
        cout << " 姓名:" << _name << endl;
        cout << " 身份证号:" << Person::_num << endl;//指定访问父类
        cout << " 学号:" << _num << endl;//默认访问子类
    }
protected:
    int _num = 999; // 学号
};
void Test()
{
    Student s1;
    s1.Print();
}

int main()
{
    Test();
    return 0;
}
//这两个num不会报错 因为两个num在不同的作用域
//那么访问num的时候到底是父类的num还是子类的nums
//子类的num 就近原则 先找自己类里面 再找其他类
//当父类和子类同时有同名成员时，子类的成员隐藏了父类的成员
//那假设就想访问父类怎么办
//指定 Person::_num

练习
A和B的fun构成什么关系

a.重载 b.重写 c.重定义 d.编译不通过/以上都不对

class A
{
public:
    void fun()
    {
        cout << "func()" << endl;
    }
};
class B : public A
{
public:
    void fun(int i) {
        A::fun();
        cout << "func(int i)->" << i << endl;
    }
};
void Test()
{
    B b;
    b.fun(10);
    //b.fun();//调父类调不动      不可以
    //b.A::fun();//指定去调父类的 可以
};

很容易选到重载应该是c 重定义也就是隐藏

隐藏不是说调不动而是要指定父类去调用

重载的要求:必须在同一作用域

5.派生类的默认成员函数

派生类的默认成员函数是如何生成的?

构造:必须调用基类的构造函数初始化基类的那一部分成员 如果基类没有构造函数构造时必须显示调用(加上作用域)
拷贝构造:必须调用基类的拷贝构造
赋值:必须调用基类的operator=
析构:派生类的析构函数调用完后自动调用基类的析构函数保证正确顺序
派生类对象初始化先调用基类构造再调派生类构造
派生类对象析构清理先调用派生类析构再调基类的析构

#include <iostream>
using namespace std;

class Person
{
public:
    Person(const char* name = "peter")//构造
        : _name(name)
    {
        cout << "Person()" << endl;
    }

    Person(const Person& p)//拷贝构造
        : _name(p._name)
    {
        cout << "Person(const Person& p)" << endl;
    }

    Person& operator=(const Person& p)//赋值
    {
        cout << "Person operator=(const Person& p)" << endl;
        if (this != &p)
            _name = p._name;

        return *this;
    }

    ~Person()//析构
    {
        cout << "~Person()" << endl;
    }
protected:
    string _name; // 姓名
};

//子类继承的父类 父类初始化就调用父类的构造函数
//子类不写默认函数 会调父类的默认构造函数 全缺省可以调
class Student :public Person
{
public:
    Student(const char* name, int stuid)
        :Person(name)//指定
        ,_stuid(stuid)
    {
        cout << "Student(const char* name, int stuid)" << endl;
    }

    Student(const Student& s)
        :Person(s)//除了stuid 其余的继承父类 先调用父类的 再调用自己的
        ,_stuid(s._stuid)
    {
        cout << "Student(const Student& s)" << endl;
    }

    Student& operator=(const Student& s)
    {
        if (this != &s)
        {
            Person::operator=(s);//调父类 完成切片 隐藏了父类 所以要指定作用域 调父类的时候全部需要指定
            _stuid = s._stuid;//自己成员
            cout << "Student& operator=(const Student& s)" << endl;
        }
        return *this;
    }

    ~Student()
    {
        //还是需要指定
        //Person::~Person();//子类的析构函数和父类的析构函数构成隐藏 因为他们的名字会被编译器统一处理成destructor(跟多态有关)
        //析构时会发现有三个析构 多一个Person析构 应该去掉第一个Person析构
        //不需要 析构函数会自动调用
        //结束时会自动调用父类的析构函数 因为这样才能保证先析构子类后析构父类
        //不需要显示的调 因为显示的调会多出一个析构 而且析构顺序不对
        cout << "~Student()" << endl;
    }
protected:
    int _stuid;
};


int main()
{
    //Student s1("jack",1);
    //Student s2(s1);//不写也会调用父类的拷贝构造 写了后先调父类 再调子类
    //Student s3 = s1;
    //Student s4("rose", 2);//析构时会发现有三个析构 多一个Person析构 应该去掉第一个Person析构
    return 0;
}

派生类实现默认成员函数时 先要调用基类相关函数把基类那一部分成员实现功能（需

要指定基类）再实现自己类里面的成员功能
析构函数比较特殊不需要去实现因为调用基类的析构函数的话基类会先析构然后派

生类再析构基类会再次析构**(当派生类析构后基类会自动调用析构函数保证析构的顺**

序)
除了析构以外全部都需要显示调用父类相当于切片那一段直接找父类的就行

然后子类自己的成员自己处理
如何设计一个不能被继承的类?

构造私有析构私有

继承后不可见私有的子类调不动父类的构造和析构子类对象都生成不了所以不能被

继承

6.继承和友元

父类中友元关系不能被继承下来

7.基类与静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少

个子类，都只有一个static成员实例。

#include <iostream>
using namespace std;

class Person
{
    public:
        Person() { ++_count; }
    protected:
        string _name; // 姓名
    public:
        static int _count; // 统计人的个数。
};
int Person::_count = 0;
class Student : public Person
{
protected:
    int _stuNum; // 学号
};
class Graduate : public Student
{
protected:
    string _seminarCourse; // 研究科目
};

int main()
{
    Person p;
    Student s;

    p._count = 1;
    s._count = 2;
    
    Person::_count++;
    cout << Person::_count << endl;
    cout << Student::_count << endl;
    //派生了多少子类 静态成员只有一个
    return 0;
}

_count都是3

8.菱形继承

1°继承类型

单继承:一个子类只有一个直接父类时称这个继承关系为单继承

多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承

菱形继承：菱形继承是多继承的一种特殊情况

菱形继承的问题:

**Assistant会有两份相同数据导致数据冗余两份数据到底用哪份产生歧义(二义性) **

需要指定是哪个但还是有数据冗余的问题

1.数据冗余

2.二义性

如何解决菱形继承问题？

官方引入了virtual继承虚继承解决了数据冗余和二义性

class Person
{
public:
    string _name; // 姓名
};
class Student : virtual public Person//添加virtual
{
protected:
    int _num; //学号
};
class Teacher : virtual public Person//添加virtual
{
protected:
    int _id; // 职工编号
};
class Assistant : public Student, public Teacher
{
protected:
    string _majorCourse; // 主修课程
};
void Test()
{
    // 这样会有二义性无法明确知道访问的是哪一个
    Assistant a;
    a._name = "peter";//不加virtual会报错

    // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
    a.Student::_name = "xxx";
    a.Teacher::_name = "yyy";
}

C++的缺陷有哪些?

多继承就是一个问题->菱形继承->虚继承->底层结构的对象模型非常复杂且有一定

效率损失

什么是菱形继承?

多继承的一种特殊情况

菱形继承问题是什么?

数据冗余和二义性

如何解决菱形继承?

虚继承

那么解决原理是什么?

需要了解内存对象模型也就是对象在内存中是怎么存的

2°内存对象模型

class A
{
public:
    int _a;
};
// class B : public A
class B : virtual public A
{
public:
    int _b;
};
// class C : public A
class C : virtual public A
{
public:
    int _c;
};
class D : public B, public C
{
public:
    int _d;
};
int main()
{
    D d;
    cout << sizeof(d) << endl;//8+8+4=20 //加了virtual变为了24
    
    d.B::_a = 1;
    d.C::_a = 2;
    d._b = 3;
    d._c = 4;
    d._d = 5;
    d._a = 6;
    //a放到了公共位置
    //多了两个像指针一样的东西 变为了24
    //所以这两个指针是干啥的
    //两个指针最后表示的是偏移量 多付出了8个字节
    //存偏移量的表叫虚基表->虚基类
    return 0;
}

这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚

基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。

通过偏移量地址(指针)->偏移量值->对象

9.总结

多继承是C++的缺陷之一，Java设计的时候避开了多继承

继承与组合

//继承
class A{};
class B:public A
{};

//组合
class C{};
class D
{
    C c;
}

继承是一种白箱(看得见)复用父类对子类基本是透明的但是一定程度破坏了父类的封装

组合是一种黑箱(看不见)复用 C对D是不透明的 C保持着封装

对比认为组合是更好的

组合的类耦合度更低

继承的类是一种高耦合

面试:用组合还是继承?

更符合is a 就继承

更符合has a 就组合

都可以优先使用组合

【C++】12.继承完

【C++】12.继承