C++ 继承

Mike!

于 2024-08-11 12:11:35 发布

阅读量914

点赞数 28

分类专栏： C++进阶文章标签： c++ java 开发语言

本文链接：https://blog.csdn.net/2301_80122797/article/details/141086456

版权

C++进阶专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1.继承

1.1 继承的概念

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法(成员函数)和属性(成员变量)，这样产生新的类，称子类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的函数层次的复用，继承是类设计层次的复用。

1.2 继承的定义

1.2.1 定义格式

下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。

1.2.2 继承父类成员访问方式的变化

类成员/继承方式	public继承	protected继承	private继承
父类的public成员	子类的public成员	子类的public成员	子类的public成员
父类的protected成员	子类的protected成员	子类的protected成员	子类的protected成员
父类的private成员	在子类中不可见	在子类中不可见	在子类中不可见

(1).父类private成员在子类中无论以什么方式继承都是不可见的。在子类类内还是类外都不能访问父类的private，但是却继承下来了。

(2).父类private成员在子类中是不能被访问，如果父类成员不想在类外直接被访问，但需要在子类中能访问，就定义为protected。

(3).，父类的私有成员在子类都是不可见。父类的其他成员在子类的访问方式 == Min(成员在父类的访问限定符，继承方式)，public > protected > privat

(4).在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用
protetced/private继承，因为protetced/private继承下来的成员都只能在子类的类里面使用，实际
中扩展维护性不强。

(5).使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

1.3 继承类模板

父类是类模板时，需要指定一下类域。

vector<T>::push_back(x);前面要加vector<T>::是为了：

明确地指定要调用的是std::vector<T>类的成员函数，而不是可能在stack类或其父类中定义的同名函数。
提高代码的可读性和维护性，清晰地表明函数的来源和意图。

namespace Mike
{
    template <class T>
    class stack : public std::vector<T>
    {
    public:
        void push(const T &x)
        {
            vector<T>::push_back(x);
        }
        void pop()
        {
            vector<T>::pop_back();
        }
        const T &top()
        {
            return vector<T>::back();
        }
        bool empty()
        {
            return vector<T>::empty();
        }
    };
}

2.父类和子类对象赋值兼容转换

(1).public继承的子类对象可以赋值给父类的对象 / 父类的指针 / 父类的引用。这里有个形象的说法叫切片或者切割。寓意把子类中父类那部分切来赋值过去。

(2).父类对象不能赋值给子类对象。

(3).父类的指针或者引用可以通过强制类型转换赋值给子类的指针或者引用。但是必须是父类的指针是指向子类对象时才是安全的。

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

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

int main()
{
    Student sobj;
    // 1.子类对象可以赋值给父类对象/指针/引用
    Person pobj = sobj;
    Person *pp = &sobj;
    Person &rp = sobj;
    // 2.父类对象不能赋值给子类对象，这里会编译报错
    sobj = pobj;
    return 0;
}

3.继承中的作用域

3.1隐藏规则

(1).在继承体系中父类和子类都有独立的作用域。

(2).子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏。（在子类成员函数中，可以使用父类::父类成员显示访问）

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

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

4.子类的默认成员函数

4.1 4个常见默认成员函数

(1).子类的构造函数必须调用父类的构造函数初始化父类的那一部分成员。如果父类没有默认的构造函数，则必须在子类构造函数的初始化列表中显示调用。

1.内置类型：不确定。

2.自定义类型：调用他的默认构造。

3.继承父类成员看作一个整体对象，要求调用父类的默认构造。

(2).子类的拷贝构造函数必须调用父类的拷贝构造完成父类的拷贝初始化。

(3).子类的析构和父类的析构也构成隐藏关系，子类析构函数之后，会自动调用父类析构。

(4).子类的operator=必须要调用父类的operator=完成父类的复制。需要注意的是子类的operator=隐藏了父类的operator=，所以显示调用父类的operator=，需要指定父类作用域。

(5).子类的析构函数会在被调用完成后自动调用父类的析构函数清理父类成员。因为这样才能保证子类对象先清理子类成员再清理父类成员的顺序。

(6).子类对象初始化先调用父类构造再调子类构造。

(7).子类对象析构清理先调用子类析构再调父类的析构。

(8).因为多态中一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们多态章节会讲解)。那么编译器会对析构函数名进行特殊处理，处理成destructor()，所以父类析构函数不加
virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

4.2 实现一个不能被继承的类

方法1：父类的构造函数私有。子类的构成必须调用父类的构造函数，但是父类的构成函数私有化以后，子类看不见就不能调用了，那么子类就无法实例化出对象。

方法2：C++11新增了一个final关键字，final修改父类，子类就不能继承了。

方法1：

class Base
{
public:
    void func5() { cout << "Base::func5" << endl; }

protected:
    int a = 1;

private:
    // C++98的方法
    Base()
    {}
};

class Derive : public Base
{
    void func4() { cout << "Derive::func4" << endl; }

protected:
    int b = 2;
};

方法2：

class Base final
{
public:
    void func5() { cout << "Base::func5" << endl; }

protected:
    int a = 1;

private:
    // C++98的方法
    // Base()
    // {}
};

class Derive : public Base
{
    void func4() { cout << "Derive::func4" << endl; }

protected:
    int b = 2;
};

5.继承和友元

友元关系不能继承，也就是说父类友元不能访问子类私有和保护成员。

6.继承与静态成员

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

7.多继承及其菱形继承问题

7.1 继承模型

(1).单继承：一个子类只有一个直接父类时称这个继承关系为单继承。
(2).多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的父类在前面，后面继承的父类在后面，子类成员在放到最后面

(3).菱形继承：

单继承：

多继承：

菱形继承：

菱形继承是多继承的一种特殊情况。菱形继承的问题，从下面的对象成员模型构造，可以
看出菱形继承有数据冗余和二义性的问题。

7.2 虚继承

用于解决菱形继承的问题

class Person
{
public:
    string _name; // 姓名
};


// 使用虚继承Person类
class Student : virtual public Person
{
protected:
    int _num; // 学号
};


// 使用虚继承Person类
class Teacher : virtual public Person
{
protected:
    int _id; // 职工编号
};


// 教授助理
class Assistant : public Student, public Teacher
{
protected:
    string _majorCourse; // 主修课程
};


int main()
{
    // 使用虚继承，可以解决数据冗余和二义性
    Assistant a;
    a._name = "peter";
    return 0;
}

Mike!

关注

28
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
C++ 继承

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许我们在保持原有类特性的基础上进行扩展，增加方法(成员函数)和属性(成员变量)，这样产生新的类，称子类。需要注意的是子类的operator=隐藏了父类的operator=，所以显示调用父类的operator=，需要指定父类作用域。(1).public继承的子类对象可以赋值给父类的对象 / 父类的指针 / 父类的引用。，多继承对象在内存中的模型是，先继承的父类在前面，后面继承的父类在后面，子类成员在放到最后面。
复制链接

扫一扫

专栏目录