0
点赞
收藏
分享

微信扫一扫

【C++】继承(上)

@TOC

1. 继承的使用

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

【C++】继承(上)_作用域

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

【C++】继承(上)_父类_02

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

【C++】继承(上)_作用域_03

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

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

【C++】继承(上)_作用域_04

【C++】继承(上)_父类_05

权限一般为 public>protected>private 所以对于基类的public成员和protected成员,继承取权限小的那一个

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

【C++】继承(上)_作用域_06

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

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

protected和private的区别

protected和private 认为都是一样的,都是在类里面可以访问,类外不能访问 只有在继承的时候才有区别,基类设置为private后,子类继承不可见

【C++】继承(上)_父类_07

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

调用父类的函数去访问

【C++】继承(上)_作用域_08

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

默认访问限定符

【C++】继承(上)_作用域_09

这里的访问限定符可以选择不写,使用默认的 使用class ,默认访问限定符为 private 使用 struct ,默认访问限定符为 public

总结

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

【C++】继承(上)_子类_10

这个块平时使用最多

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

在共有继承的前提下,将子类对象赋值给父类对象 天然支持,不存在类型转换发生,认为子类对象就是特殊的父类对象

【C++】继承(上)_父类_11

【C++】继承(上)_作用域_12

在Student类中,把父类的那部分找到,依次传递过去(具体如何切割后面会讲) 这个过程被叫做 切割或者切片

【C++】继承(上)_父类_13

由于d是double类型,而i是int类型,将d赋值给i会发生隐式类型转换,产生一个int类型的临时变量,再将临时变量传给i 但是由于临时变量具有常性,所以i需要使用const修饰

【C++】继承(上)_父类_14

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

【C++】继承(上)_作用域_15

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

【C++】继承(上)_子类_16

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

4. 继承中的作用域

1.在继承体系中基类和派生类都有独立的作用域 2.子类和父类有同名成员,子类成员将屏蔽父类对同名成员的直接访问,这种情况也叫隐藏,或者重定义 (在子类成员函数中,可以使用 基类::基类成员 显示访问) 3.需要注意的是如果是成员函数的隐藏,只需要函数名相同就构成隐藏 4.注意在实际中的继承体系里面最好不要定义同名的成员

【C++】继承(上)_父类_17

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

【C++】继承(上)_子类_18

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

与函数重载的区别

【C++】继承(上)_子类_19

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;
}

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

构造函数

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

【C++】继承(上)_子类_20

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

【C++】继承(上)_子类_21

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

拷贝构造函数

【C++】继承(上)_子类_22

子类的拷贝构造需要调用父类的拷贝构造 Person&p=s ,p作为子类Student中父类那部分的别名,被称之为切片或者切割

切片传递原理

【C++】继承(上)_作用域_23

实际上会调用父类的拷贝构造函数 p作为父类的引用,可以看作子类中父类那部分的别名 将子类中属于父类的那部分依次拷贝给父类

operator=

【C++】继承(上)_父类_24

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

【C++】继承(上)_作用域_25

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

析构函数

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

【C++】继承(上)_子类_26

在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;
}

【C++】继承(上)_子类_27

父类会析构两次

【C++】继承(上)_作用域_28

析构函数不要显示调用,因为会自动调用 构造时,先构造父类,在构造子类,所以析构时,要先析构子类,在析构父类 自己实现的不能保证先析构子类,在析构父类 所以在子类的析构函数完成时,会自动调用父类的析构函数,保证先析构子,在析构父

【C++】继承(上)_子类_29

6. 友元关系不能被继承

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

【C++】继承(上)_父类_30

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. 菱形继承

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

【C++】继承(上)_父类_31

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

数据冗余和二义性

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

【C++】继承(上)_子类_32

【C++】继承(上)_子类_33

会导致在对象中存在两份人的信息 就存在数据冗余和二义性 二义性:直接访问不知道访问谁,因为有两个父类带来的两个名字

【C++】继承(上)_子类_34

Student和Teacher都是Person的子类,所以他们两个都可以调用父类Person的_name 而Assistant作为Student和Teacher的子类,当然也可以调用_name Assistant子类中有两个名字存在 ,不知道该调用谁,即二义性

指定访问可以解决二义性

【C++】继承(上)_子类_35

【C++】继承(上)_作用域_36

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

举报

相关推荐

c++ 继承

C++继承

C++ - 继承

【C++】继承

c++(继承)

0 条评论