【C++】继承(上)

1. 继承的使用

若有好多类，都有公共的特征，将类中的特性提取出来专门放在一个类中，这个类一般叫做基类或者父类

public作为继承方式

继承方式共有三种 :public protected private

Stuent 类内部虽然没有实现name和age，但是它继承了person父类的name和age

父类可以叫做基类 ，子类也可以叫做派生类

2. 继承基类成员访问方式的变化

权限一般为 public>protected>private

所以对于基类的public成员和protected成员，继承取权限小的那一个

如果基类为private成员，任何继承方式都是不可见的,不可见就是不能用

若将父类中的name设置为private，则子类stuent 没办法去调用父类中的成员变量name

不想要被子类继承，就可以设置为private

protected和private的区别

protected和private 认为都是一样的，都是在类里面可以访问，类外不能访问

只有在继承的时候才有区别，基类设置为private后，子类继承不可见

而基类设置为protected后，子类继承可以使用

调用父类的函数去访问

虽然基类的成员变量是由private修饰的，只是派生类中不可以用，但是子类student 可以调用父类的函数去访问

默认访问限定符

这里的访问限定符可以选择不写，使用默认的

使用class ，默认访问限定符为 private

使用 struct ，默认访问限定符为 public

总结

实际当中基类都是public/protected成员，派生类基本都是public继承

这个块平时使用最多

3. 基类和派生类对象的赋值转换

在共有继承的前提下，将子类对象赋值给父类对象

天然支持，不存在类型转换发生，认为子类对象就是特殊的父类对象

在Student类中，把父类的那部分找到，依次传递过去(具体如何切割后面会讲)

这个过程被叫做 切割或者切片

由于d是double类型，而i是int类型，将d赋值给i会发生隐式类型转换，产生一个int类型的临时变量，再将临时变量传给i

但是由于临时变量具有常性，所以i需要使用const修饰

而此时由于不想要const修饰，所以说明没有产生临时变量

p是子类对象当中父类那一部分的别名

ptrp指针 指向子类中父类的那一部分

4. 继承中的作用域

1.在继承体系中基类和派生类都有独立的作用域

2.子类和父类有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况也叫隐藏，或者重定义

(在子类成员函数中，可以使用 基类::基类成员 显示访问)

3.需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏

4.注意在实际中的继承体系里面最好不要定义同名的成员

因为父类和子类在不同的作用域，所以可以分别在父子类中创建相同的成员变量，但是这样只会访问子类的成员变量

若想传的是父类的_num，需要指定作用域

与函数重载的区别

fun函数，看似很像进行函数重载，但是函数重载是在同一个作用域下的

而子类B是继承的父类A，两者属于不同的作用域

所以fun函数构成隐藏或者重定义

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

#include<iostream>
#include<string>
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
{
protected :
    int _num;
};
int main()
{
    Student s;// Person() 
             // ~Person()
    return 0;
}

虽然子类中什么都没写，但是调用子类对象时会自动调用父类中构造函数和析构函数

构造函数

父类的成员必须调用父类的构造函数初始化

name属于父类的成员，所以要去调用父类的构造函数初始化

如果不写，会在初始化列表去调用父类的默认构造函数(自己实现的全缺省的构造函数)

拷贝构造函数

子类的拷贝构造需要调用父类的拷贝构造

Person&p=s ，p作为子类Student中父类那部分的别名，被称之为切片或者切割

切片传递原理

实际上会调用父类的拷贝构造函数

p作为父类的引用，可以看作子类中父类那部分的别名

将子类中属于父类的那部分依次拷贝给父类

operator=

同样子类使用operator=，也需要调用父类的operator=

但是实际使用时报错，因为子类的operator= 与父类的operator= 形成隐藏，会优先使用子类的operator=，所以会无限循环使用子类的operator= 从而报错

在子类的operator=前面指定作用域，从而调用父类的operator=

析构函数

由于多态的原因，所以析构函数会被处理成Destructor，而父子类都是Destructor 就会形成隐藏

在Person前面加上指定作用域即可实现

#include<iostream>
#include<string>
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 num)
        : _num(num)
    {
        cout << "Student()" << endl;
    }
    //拷贝构造函数
    Student (const Student &s)
        :Person(s)
        ,_num(s._num)
    {
    }
    //operator赋值
    Student& operator=(const Student& s)
    {
        if (this != &s)
        {
            Person::operator=(s);
            _num = s._num;
        }
        return *this;
    }
    //析构函数
    ~Student()
    {
        Person::~Person();
        cout << "~Student()" << endl;
    }
protected :
    int _num;
};
int main()
{
    Student s1("李四", 20);
    return 0;
}

父类会析构两次

析构函数不要显示调用，因为会自动调用

构造时，先构造父类，在构造子类，所以析构时，要先析构子类，在析构父类

自己实现的不能保证先析构子类，在析构父类

所以在子类的析构函数完成时，会自动调用父类的析构函数，保证先析构子，在析构父

6. 友元关系不能被继承

有一个函数，是你父类的友元，不是你子类的友元

Display作为父类的友元函数，可以访问父类的成员变量，但是不能访问子类的成员变量

7. 继承与静态成员

继承并不会把static修饰的静态成员变量继承下来，但是可以访问它

静态成员变量属于整个类，即属于父类，也属于子类

#include<iostream>
#include<string>
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; // 学号
};
int main()
{
    Person s;
    Student p;
    cout << &(s._count) << endl;//00007FF77BEA2444
    cout << &(p._count) << endl;//00007FF77BEA2444
    return 0;
}

在父类和子类中，都可以调用_count，并且地址相同，说明是同一个_count

8. 菱形继承

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

假设Student类为水果，Teacher类为蔬菜，圣女果就具备了既是水果 又是蔬菜的特征

数据冗余和二义性

多继承可能会导致菱形继承

会导致在对象中存在两份人的信息

就存在数据冗余和二义性

二义性：直接访问不知道访问谁，因为有两个父类带来的两个名字

Student和Teacher都是Person的子类，所以他们两个都可以调用父类Person的_name

而Assistant作为Student和Teacher的子类，当然也可以调用_name

Assistant子类中有两个名字存在 ，不知道该调用谁，即二义性

指定访问可以解决二义性

但是实际上依旧是不合理的，若再传入年龄、电话、住址等信息，由于这些信息都是相同的，只有名字不同，相当于把名字多存了，就会造成数据冗余，本质为空间浪费