面向对象之继承-优快云博客

本文链接：https://blog.youkuaiyun.com/mxrrr_sunshine/article/details/81080811

继承的相关概念

继承是面向对象复用的重要手段。继承是类型之间的关系建模，通过继承类的关系，可以达到复用的目的。比如下面这个例子：

老师，学生，保安都可以由人这个类继承下来。

这里写图片描述

实现一个简单的类

这里写图片描述

继承是一种复用手段，在继承关系里父类的成员都会变成子类的一部分

三种继承方式

public：公有继承
private：私有继承
protected：保护继承

三种继承关系下父类成员在子类的访问关系变化：
这里写图片描述

总的来说：当继承方式与基类的成员限定符不一致时，谁小就取谁。

基类的private成员不可见，这里的不可见的意思是，该private成员就在那里，是实际存在的，但是谁都不可以访问。

总结：

public继承是is-a的关系，每个子类对象也是一个父类对象
private/protected继承是has-a的关系。

赋值兼容规则

切割的行为：
这里写图片描述

但是注意：在切片的过程中并没有类型的转换,是天然的操作,只是把父类需要的东西从子类中取出来;

//父类的指针可以指向子类的对象
Person* p1=&s;
//父类的引用可以指向子类的对象
Person& p2=s;


//子类的指针/引用不能指向父类的对象（可以通过强制类型转换完成）
Student* s1=(Student*)&p;
Student& s2=(Student&)p;
//但是这种方式可能会造成越界，因为强转之后编译器会多向后找四个字节，这样就会造成越界的可能性。

继承中的作用域

在继承体系中基类和派生类都有独立的作用域
子类和父类中有同名成员，子类成员将屏蔽父类对成员的直接访问。这称作–隐藏/重定义
所以在继承体系中最好不要定义同名的成员

class Person
{
public:
    void Display()
    {
        cout<<_name<<endl;
    }
    void f()
    {
        cout<<"Person()"<<endl;
    }
protected:
    string _name;
};

class Student: public Person
{
public:
    void f(int a)
    {
        cout<<"Person()"<<endl;
    }
public:
        int _num;
};

此时，子类的f()同样会隐藏父类的f(),在不同作用域内，并不构成重载。所以这里所说的函数名相同，是指不论返回值，参数列表是否相同，函数名相同的就会被隐藏。但是可以通过指定类域显式地访问。

继承的默认成员函数

在继承关系中，如果没有显式地定义这六个默认成员函数，编译系统会默认合成这六个默认成员函数。

写一个例子：

class Person//父类的成员函数
{
public:
    Person(char* name)
        :_name(name)
    {
        cout<<"Person()"<<endl;
    }
    Person(const Person& p)
       :_name(p._name) 
    {
        cout<<"Person(const Person& p)"<<endl;
    }
    Person& operator=(const Person& p)
    {
        cout<<"operator=()"<<endl;
        if(this!=&p)
        {
            _name=p._name;
        }
        return *this;
    }
    ~Person()
    {
        cout<<"~Person()"<<endl;
    }
protected:
    string _name;
};


class Student: public Person
{
public:
    Student(char* name,int num)
        :Person(name)
        ,_num(num)
    {
        cout<<"Student()"<<endl;
    }

    Student(const Student& s)
        :Person(s)
         ,_num(s._num)
    {
        cout<<"Student(const Student& s)"<<endl;
    }

    Student& operator=(const Student& s)
    {
        if(this!=&s)
        {
            Person::operator=(s);//必须指定父类的域，否则会无限递归
            _num=s._num;
        }
        return *this;
    }

    ~Student()
    {
        cout<<"~Student()"<<endl;
    }
private:
    int _num;
};

void test()
{
    Student s1("jack",18);
    Student s2(s1);
    Student s3("rode",12);
    s1=s3;
}