【C++】继承|切片|菱形继承|虚继承

2024-06-12 00:52
文章标签 c++ 切片 继承 菱形

本文主要是介绍【C++】继承|切片|菱形继承|虚继承,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

目录

​编辑

一.什么是继承

 三大特性

继承的语法

访问控制 

继承的总结

二.继承的作用域 

三.切片 

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

构造函数

 析构函数

拷贝构造

赋值运算符重载

五.单继承和多继承

单继承

多继承

菱形继承

解决方式

六.虚继承 


 

一.什么是继承

C++中的继承是面向对象编程的一个重要特性,它允许一个类(称为子类或派生类)继承另一个类(称为基类或父类)的属性和方法。是最重要的代码复用的手段

是一种在原有基础上进行拓展,增加功能,产生新类的方式;

体现了由简单到复杂的认知过程。

 三大特性

面向对象语言有三大特性:封装,继承,多态

封装:

1:数据和方法放到一起,把想给访问定义成公有,不想给你访问定义成私有和保护。

2:一个类型放到另一个类型里面,通过typedef 成员函数调整,封装另一个全新的类型。

比如STL库中的vector,list等,都是将一系列函数封装到一起。

继承:

允许一个类(称为子类或派生类)获取另一个类(称为父类或基类)的属性和行为。通过继承,子类可以重用父类的代码,同时还可以扩展和修改这些代码以满足自己的需求。

多态:

指的是同一个方法调用在不同的对象上可以表现出不同的行为。(下篇讲)

继承的语法

// 基类定义
class Base {// 成员变量和方法
};// 派生类定义
//class 新类的名字:继承方式 继承类的名字{};
class Derived : public Base {// 派生类可以添加新的成员或覆盖基类方法
};

继承体现的是一种代码的复用,将大家都会有的数据,整合到一起形成一个新的类,大家都可以共享,避免了数据的重复。

class Person
{
public:void Print(){cout << "name:" << _name << endl;cout << "age:" << _age << endl;}
protected:string _name = "MM";  //姓名int _age = 18;  //年龄
};class Student :public Person
{
protected:int _stid;    //学号
};int main()
{Student s;cout << "Student:";s.Print();return 0;
}

访问控制 

使用public, protected, private关键字来控制成员的访问级别

public,和protected继承,子类都可以直接访问使用

protected只能在类中public,没限制,private,不能直接访问

public>protected>private

继承的总结

1.基类private成员无论以什么方式继承到派生类中都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中,但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2.基类private成员在派生类中不能被访问如果基类成员不想在派生类外直接被访问,但需要在派生类中访问,就定义为protected。可以看出保护成员限定符是因继承才出现的。
3.基类的私有成员在子类都是不可见;基类的其他成员在子类的访问方式就是访问限定符和继承方式中权限更小的那个(权限排序:public>protected>private)。
4.使用关键字class时默认的继承方式是private,使用struct时默认的继承方式是public,但最好显式地写出继承方式。

总结:

如果父类内是public成员和protected成员的话,继承后会根据继承方式的改变而将权限变小

二.继承的作用域 

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

 例1:成员变量的隐藏

class Person	//基类
{
protected:string _name = "MM";int _num = 123456;//身份证号
};
class Student :public Person
{
public:void Print(){cout << "姓名:" << _name << endl;cout << "学号:" << _num << endl;cout << "身份证号:" << _num << endl;			//构成隐藏,显示的是派生类成员cout << "身份证号:" << Person::_num << endl;			//显示用指定域名方式找到父类的成员变量}
protected:int _num = 202469;//学号	//成员和基类构成隐藏 (同名)
};
int main()
{Student s;s.Print();return 0;
}

 例2:成员函数的隐藏

class Base	//基类
{
public:void func(){cout << "Base::func()" << endl;}
};
class Derive :public Base
{
public:void func()		//满足同名,构成隐藏{cout << "Derive::func()" << endl;}
};int main()
{Derive d;d.func();return 0;
}

下面这个,可以看到明明继承了父类,但是还是会报错,因为两个构成了隐藏(同名)

class Base	//基类
{
public:void func(){cout << "Base::func()" << endl;}
};
class Derive :public Base
{
public:void func(int i)		//  注意这里!!!满足同名,构成隐藏 {cout << "Derive::func()" << endl;}
};int main()
{Derive d;d.func();return 0;
}

总的来说,是局部优先原则, 在这个程序中就是,先在子类中查找,子类中没有才会去父类中查找,但是在子类中找到了函数名。在这里不构成重载,因为重载要在同一作用域 

三.切片 

切片派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。

基类对象不能赋值给派生类对象。

基类的指针或者引用可以通过强制类型转换赋值给派生类的指针或者引用。但是必须是基类的指针是指向派生类对象时才是安全的。

class Base
{
protected:string _name;string _sex;int _age;
};class Derive:public Base
{
public:int _id;
};int main()
{Derive d;Base* b = &d;	//指针Base b1 = d;	//对象Base& b2 = d;	//引用return 0;
}

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

构造函数

编译器会默认先调用父类的构造函数,再调用子类的构造函数。

因为会先调用基类,所以先要确保父类的默认构有效(有效传参,全省,满足初始化)

class Base
{
public:Base(){cout << "Base()" << endl;}};
class Derive:public Base
{
public:Derive()	//默认构造函数,先构造基类 再构造派生类{cout << "Derive()" << endl;}
};int main()
{Derive d;return 0;
}

 

 析构函数

析构函数和构造函数相反。

编译器默认先调用子类的析构函数,再调用父类的析构函数。

派生类析构会自动调用基类的析构

        切勿在派生类主动调用基类析构,        

        如果是指针类型,那么同一块区域被析构两次就会造成野指针的问题。

class Base
{
public:Base(){cout << "Base()" << endl;}~Base()	{cout << "~Base()" << endl;}};
class Derive:public Base
{
public:Derive()	//默认构造函数,先构造基类 再构造派生类{cout << "Derive()" << endl;}~Derive()		//会自动调用基类析构{cout << "~Derive()" << endl;	//Base::~Base();}
};
int main()
{Derive d;return 0;
}

 

拷贝构造

子类中调用父类的拷贝构造时,直接传入子类对象即可,父类的拷贝构造会通过“切片”拿到父类的那一部分

class Person
{
public:Person(string name = "MM")	//缺省  保证基类有效默认构造:_name(name)	//初始化列表{cout << "name:" << _name << endl;}
protected:string _name;
};
class Studen :public Person
{
public:Studen(int age = 1):_age(age){cout << "age:" << _age << endl;}Studen(Studen& s):Person(s)			//派生类对象s 通过切片拿到基类中的值,传给基类, _age(s._age)			//取派生类特有的值{cout << s._age <<" " << s._name << endl;}protected:int _age;
};
int main()
{Studen s;Studen s1(s);return 0;
}

赋值运算符重载

子类的operator=必须要显式调用父类的operator=完成父类的赋值。

因为子类和父类的运算符,编译器默认给与了同一个名字,所以构成了隐藏,所以每次调用=这个赋值运算符都会一直调用子类,会造成循环,所以这里的赋值要直接修饰限定父类.

class Person
{
public:Person(string name = "MM")	//缺省  保证基类有效默认构造:_name(name)	//初始化列表{cout << "name:" << _name << endl;}Person& operator=(Person& p){if (this != &p){cout << "调用基类=" << endl;_name = p._name;}return *this;}
protected:string _name;
};
class Studen :public Person
{
public:Studen(string name, int age):_age(age){}Studen(Studen& s)	//拷贝:Person(s),_age(s._age){}Studen& operator=(Studen& s){if (this != &s)	//判断是否自己给自己赋值{cout << "调用子类" << endl;Person::operator=(s); //先给基类赋值_age = s._age;_name = s._name;}return *this;}
protected:int _age;
};
int main()
{Studen s("MM",18);Studen s1(s);Studen s2("mm", 100);s = s2;	return 0;
}

五.单继承和多继承

单继承

一个子类只有一个直接父类的继承关系。

多继承

一个子类有两个或以上直接父类的继承关系。

菱形继承

有了多继承,自然就会出现菱形继承菱形继承是多继承的一种特殊情况

菱形继承内数据冗余和二义性问题

class A {
public:string name;
};
class B :public A {	//类B 里面有了份类A的成员变量
public:int age;
};
class C :public A {  //类C 里面有了份类A的成员变量
public:string sex;
};
class D :public B, public C {  //类D继承了B,C 不仅拥有了这两个基类特有的成员变量,//也有了基类自己继承的成员变量 这里有了两份类A的成员变量
public:int id;
};
int main()
{D d;d.name = "MM";d.age = 18;d.sex = "男";d.id = 666;return 0;
}

 

类B,C都继承了类A的name,所以D不知道继承B的name还是C中的name

这也就是引出了代码冗余和二义性的问题。

解决方式

加修饰限定,指定类域;

	d.C::name = "MM";

使用虚函数,在继承方式前加上virtual。(在腰间使用)

class B :virtual  public A {
public:int age;
};
class C :virtual public A {
public:string sex;
};

六.虚继承 

C++中的虚继承是一种特殊的继承方式,用于解决多重继承中的菱形继承问题

在菱形继承中,一个基类被两个或多个派生类继承,然后这些派生类又共同派生出一个最终类。如果不使用虚继承,最终类将包含多个基类的副本,这会导致数据冗余和不一致性问题。

虚继承通过在派生类中共享基类的单一实例来解决这个问题。这意味着所有通过虚继承得到的基类子对象在内存中只有一份拷贝,所有派生类共享这个拷贝。

不使用虚继承情况下(指定域)

 

使用虚继承

 

使用虚继承时,要注意以下几点:

虚继承通过关键字 virtual 来实现。

虚继承的基类成员在派生类中是共享的,而不是复制的。

虚继承可以避免多重继承中的二义性问题。

虚继承可能会稍微增加程序的复杂性,因为需要处理虚指针和虚基类表。

 

 

这篇关于【C++】继承|切片|菱形继承|虚继承的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1052736

相关文章

【C++ Primer Plus习题】13.4

大家好,这里是国中之林! ❥前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到网站。有兴趣的可以点点进去看看← 问题: 解答: main.cpp #include <iostream>#include "port.h"int main() {Port p1;Port p2("Abc", "Bcc", 30);std::cout <<

C++包装器

包装器 在 C++ 中,“包装器”通常指的是一种设计模式或编程技巧,用于封装其他代码或对象,使其更易于使用、管理或扩展。包装器的概念在编程中非常普遍,可以用于函数、类、库等多个方面。下面是几个常见的 “包装器” 类型: 1. 函数包装器 函数包装器用于封装一个或多个函数,使其接口更统一或更便于调用。例如,std::function 是一个通用的函数包装器,它可以存储任意可调用对象(函数、函数

C++11第三弹:lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页: 南桥几晴秋 🌈C++专栏: 南桥谈C++ 🌈C语言专栏: C语言学习系列 🌈Linux学习专栏: 南桥谈Linux 🌈数据结构学习专栏: 数据结构杂谈 🌈数据库学习专栏: 南桥谈MySQL 🌈Qt学习专栏: 南桥谈Qt 🌈菜鸡代码练习: 练习随想记录 🌈git学习: 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�

【C++】_list常用方法解析及模拟实现

相信自己的力量,只要对自己始终保持信心,尽自己最大努力去完成任何事,就算事情最终结果是失败了,努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一:什么是list? •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二:list常用接口 •🌰1.默认成员函数 🔥构造函数(⭐) 🔥析构函数 •🌰2.list对象

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获:包含零个或者多个捕获符的逗号分隔列表 模板形参:用于泛型lambda提供个模板形参的名

6.1.数据结构-c/c++堆详解下篇(堆排序,TopK问题)

上篇:6.1.数据结构-c/c++模拟实现堆上篇(向下,上调整算法,建堆,增删数据)-CSDN博客 本章重点 1.使用堆来完成堆排序 2.使用堆解决TopK问题 目录 一.堆排序 1.1 思路 1.2 代码 1.3 简单测试 二.TopK问题 2.1 思路(求最小): 2.2 C语言代码(手写堆) 2.3 C++代码(使用优先级队列 priority_queue)

【C++高阶】C++类型转换全攻略:深入理解并高效应用

📝个人主页🌹:Eternity._ ⏩收录专栏⏪:C++ “ 登神长阶 ” 🤡往期回顾🤡:C++ 智能指针 🌹🌹期待您的关注 🌹🌹 ❀C++的类型转换 📒1. C语言中的类型转换📚2. C++强制类型转换⛰️static_cast🌞reinterpret_cast⭐const_cast🍁dynamic_cast 📜3. C++强制类型转换的原因📝

C++——stack、queue的实现及deque的介绍

目录 1.stack与queue的实现 1.1stack的实现  1.2 queue的实现 2.重温vector、list、stack、queue的介绍 2.1 STL标准库中stack和queue的底层结构  3.deque的简单介绍 3.1为什么选择deque作为stack和queue的底层默认容器  3.2 STL中对stack与queue的模拟实现 ①stack模拟实现

c++的初始化列表与const成员

初始化列表与const成员 const成员 使用const修饰的类、结构、联合的成员变量,在类对象创建完成前一定要初始化。 不能在构造函数中初始化const成员,因为执行构造函数时,类对象已经创建完成,只有类对象创建完成才能调用成员函数,构造函数虽然特殊但也是成员函数。 在定义const成员时进行初始化,该语法只有在C11语法标准下才支持。 初始化列表 在构造函数小括号后面,主要用于给

2024/9/8 c++ smart

1.通过自己编写的class来实现unique_ptr指针的功能 #include <iostream> using namespace std; template<class T> class unique_ptr { public:         //无参构造函数         unique_ptr();         //有参构造函数         unique_ptr(