继承和派生

于 2024-06-28 15:58:40 发布
阅读量1k 收藏 12
点赞数 20
文章标签： java 开发语言 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_83614570/article/details/140019629
版权

继承和派生

继承概述

为什么需要继承

使用继承，可以复用已有的代码

继承基本概念

c++最重要的特征是代码重用，通过继承机制可以利用已有的数据类型来定义新的数据类型，新的类不仅拥有旧类的成员，还拥有新定义的成员。

派生类中的成员，包含两大部分：

  1. 一类是从基类继承过来的，一类是自己增加的成员。
  2. 从基类继承过过来的表现其共性，而新增的成员体现了其个性。
    在这里插入图片描述

派生类定义

派生类定义格式：

   Class 派生类名 :  继承方式 基类名{
         //派生类新增的数据成员和成员函数
   }

从继承源上分：

  1. 单继承：指每个派生类只直接继承了一个基类的特征
  2. 多继承：指多个基类派生出一个派生类的继承关系,多继承的派生类直接继承了不止一个基类的特征

派生类访问控制

在这里插入图片描述
在这里插入图片描述

继承中的构造和析构

继承中的对象模型

在C++编译器的内部可以理解为结构体，子类是由父类成员叠加子类新成员而成：

class Aclass{
public:
	int mA;
	int mB;
};
class Bclass : public Aclass{
public:
	int mC;
};
class Cclass : public Bclass{
public:
	int mD;
};
void test(){
	cout << "A size:" << sizeof(Aclass) << endl;
	cout << "B size:" << sizeof(Bclass) << endl;
	cout << "C size:" << sizeof(Cclass) << endl;
}

对象构造和析构的调用原则

  1. 子类对象在创建时会首先调用父类的构造函数
  2. 父类构造函数执行完毕后，才会调用子类的构造函数
  3. 当父类构造函数有参数时，需要在子类初始化列表(参数列表)中显示调用父类构造函数
  4. 析构函数调用顺序和构造函数相反
    在这里插入图片描述

继承中同名成员的处理方法

  1. 当子类成员和父类成员同名时，子类依然从父类继承同名成员
  2. 如果子类有成员和父类同名，子类访问其成员默认访问子类的成员(本作用域，就近原则)
  3. 在子类通过作用域::进行同名成员区分(在派生类中使用基类的同名成员，显示使用类名限定符)
class Base{
public:
	Base():mParam(0){}
	void Print(){ cout << mParam << endl; }
public:
	int mParam;
};

class Derived : public Base{
public:
	Derived():mParam(10){}
	void Print(){
		//在派生类中使用和基类的同名成员,显示使用类名限定符
		cout << Base::mParam << endl;
		cout << mParam << endl;
	}
	//返回基类重名成员
	int& getBaseParam(){ return  Base::mParam; }
public:
	int mParam;
};

int main(){

	Derived derived;
	//派生类和基类成员属性重名，子类访问成员默认是子类成员
	cout << derived.mParam << endl; //10
	derived.Print();
	//类外如何获得基类重名成员属性
	derived.getBaseParam() = 100;
	cout << "Base:mParam:" << derived.getBaseParam() << endl;

	return EXIT_SUCCESS;
}

如果重新定义了基类中的重载函数，将会发生什么？

class Base{
public:
	//重载函数
	void func1(){
		cout << "Base::void func1()" << endl;
	};
	void func1(int param){
		cout << "Base::void func1(int param)" << endl;
	}
	//非重载函数
	void myfunc(){
		cout << "Base::void myfunc()" << endl;
	}
};

class Derived1 : public Base{};
class Derived2 : public Base{
public:
	void myfunc(){
		//基类myfunc被隐藏，可通过类作用域运算符指定调用基类myfunc函数
		//Base::myfunc();
		cout << "Derived2::void myfunc()" << endl;
	}
};
class Derived3 : public Base{
public:
	//改变成员函数的参数列表
	void func1(int param1, int param2){
		//Base::func1(10);  //类的内部可通过类作用域运算符访问基类重载版本的函数
		cout << "Derived3::void func1(int param1,int param2)" << endl;
	};
};
class Derived4 : public Base{
public:
	//改变成员函数的返回值
	int func1(int param){
		Base::func1(10);
		cout << "Derived4::int func1(int param)" << endl;
		return 0;
	}
};

//和基类非重载函数重名
void test01(){
	Derived1 derived1;
	derived1.myfunc();
	//和基类函数重名
	Derived2 derived2;
	derived2.myfunc();
}

//和基类重载函数重名
void test02(){

	Derived3 derived3;
	//derived3.func1();  //基类重载版本的函数fun1被全部隐藏，子类外部不可访问
	//derived3.func1(10);
	derived3.func1(10,20);

	Derived4 derived4;
	//derived4.func1(); //基类重载版本的函数fun1被全部隐藏，子类外部不可访问
	derived4.func1(10);
}

//结论：任何时候重新定义基类中的任何一个函数，子类中这种函数的任何版本都会被隐藏(非覆盖，可通过类作用域运算符调用)

任何时候重新定义基类中的一个重载函数，在新类中所有的其他版本将被自动隐藏.

非自动继承的函数

不是所有的函数都能自动从基类继承到派生类中。
构造函数和析构函数用来处理对象的创建和析构操作，构造和析构函数只知道对它们的特定层次的对象做什么，也就是说构造函数和析构函数不能被继承，必须为每一个特定的派生类分别创建。

另外operator=也不能被继承，因为它完成类似构造函数的行为。也就是说尽管我们知道如何由=右边的对象如何初始化=左边的对象的所有成员，但是这个并不意味着对其派生类依然有效。

在继承的过程中，如果没有创建这些函数，编译器会自动生成它们。

继承中的静态成员特性

静态成员函数不能是虚函数（virtual function）

静态成员函数和非静态成员函数的共同点:

  1. 他们都可以被继承到派生类中。
  2. 如果重新定义一个静态成员函数，所有在基类中的其他重载函数会被隐藏。
  3. 如果我们改变基类中一个函数的特征，所有使用该函数名的基类版本都会被隐藏。
class Base{
public:
	static int getNum(){ return sNum; }
	static int getNum(int param){
		return sNum + param;
	}
public:
	static int sNum;
};
int Base::sNum = 10;

class Derived : public Base{
public:
	static int sNum; //基类静态成员属性将被隐藏
#if 0
	//重定义一个函数，基类中重载的函数被隐藏
	static int getNum(int param1, int param2){
		return sNum + param1 + param2;
	}
#else
	//改变基类函数的某个特征，返回值或者参数个数，将会隐藏基类重载的函数
	static void getNum(int param1, int param2){
		cout <<  sNum + param1 + param2 << endl;
	}
#endif
};
int Derived::sNum = 20;

多继承

多继承的概念

我们可以从一个类继承，我们也可以能同时从多个类继承，这就是多继承。但是由于多继承是非常受争议的，从多个类继承可能会导致函数、变量等同名导致较多的歧义。
在这里插入图片描述

class Base1{
public:
	void func1(){ cout << "Base1::func1" << endl; }
};
class Base2{
public:
	void func1(){ cout << "Base2::func1" << endl; }
	void func2(){ cout << "Base2::func2" << endl; }
};
//派生类继承Base1、Base2
class Derived : public Base1, public Base2{};
int main(){

	Derived derived;
	//func1是从Base1继承来的还是从Base2继承来的？
	//derived.func1(); 
	derived.func2();

	//解决歧义:显示指定调用那个基类的func1
	derived.Base1::func1(); 
	derived.Base2::func1();

	return EXIT_SUCCESS;
}

多继承会带来一些二义性的问题， 如果两个基类中有同名的函数或者变量，那么通过派生类对象去访问这个函数或变量时就不能明确到底调用从基类1继承的版本还是从基类2继承的版本？

解决方法就是显式指定调用那个基类的版本。

菱形继承和虚继承

两个派生类继承同一个基类而又有某个类同时继承者两个派生类，这种继承被称为菱形继承，或者钻石型继承。

在这里插入图片描述

这种继承所带来的问题：

  1. 羊继承了动物的数据和函数，鸵同样继承了动物的数据和函数，当草泥马调用函数或者数据时，就会产生二义性。
  2. 草泥马继承自动物的函数和数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。
class BigBase{
public:
	BigBase(){ mParam = 0; }
	void func(){ cout << "BigBase::func" << endl; }
public:
	int mParam;
};

class Base1 : public BigBase{};
class Base2 : public BigBase{};
class Derived : public Base1, public Base2{};

int main(){

	Derived derived;
	//1. 对“func”的访问不明确
	//derived.func();
	//cout << derived.mParam << endl;
	cout << "derived.Base1::mParam:" << derived.Base1::mParam << endl;
	cout << "derived.Base2::mParam:" << derived.Base2::mParam << endl;

	//2. 重复继承
	cout << "Derived size:" << sizeof(Derived) << endl; //8

	return EXIT_SUCCESS;
}

上述问题如何解决？对于调用二义性，那么可通过指定调用那个基类的方式来解决，那么重复继承怎么解决？

对于这种菱形继承所带来的两个问题，c++为我们提供了一种方式，采用虚基类。那么我们采用虚基类方式将代码修改如下：

class BigBase{
public:
	BigBase(){ mParam = 0; }
	void func(){ cout << "BigBase::func" << endl; }
public:
	int mParam;
};

class Base1 : virtual public BigBase{};
class Base2 : virtual public BigBase{};
class Derived : public Base1, public Base2{};

int main(){

	Derived derived;
	//二义性问题解决
	derived.func();
	cout << derived.mParam << endl;
	//输出结果:12
	cout << "Derived size:" << sizeof(Derived) << endl;

	return EXIT_SUCCESS;
}

以上程序Base1 ，Base2采用虚继承方式继承BigBase,那么BigBase被称为虚基类。

通过虚继承解决了菱形继承所带来的二义性问题。

虚继承实现原理

  1. BigBase 菱形最顶层的类，内存布局图没有发生改变。
  2. Base1和Base2通过虚继承的方式派生自BigBase,这两个对象的布局图中可以看出编译器为我们的对象中增加了一个vbptr (virtual base pointer),vbptr指向了一张表，这张表保存了当前的虚指针相对于虚基类的首地址的偏移量。
  3. Derived派生于Base1和Base2,继承了两个基类的vbptr指针，并调整了vbptr与虚基类的首地址的偏移量

由此可知编译器帮我们做了一些幕后工作，使得这种菱形问题在继承时候能只继承一份数据，并且也解决了二义性的问题。

当使用虚继承时，虚基类是被共享的，也就是在继承体系中无论被继承多少次，对象内存模型中均只会出现一个虚基类的子对象（这和多继承是完全不同的）。

即使共享虚基类，但是必须要有一个类来完成基类的初始化（因为所有的对象都必须被初始化，哪怕是默认的），同时还不能够重复进行初始化，

那到底谁应该负责完成初始化呢？

C++标准中选择在每一次继承子类中都必须书写初始化语句（因为每一次继承子类可能都会用来定义对象），但是虚基类的初始化是由最后的子类完成，其他的初始化语句都不会调用。

class BigBase{
public:
	BigBase(int x){mParam = x;}
	void func(){cout << "BigBase::func" << endl;}
public:
	int mParam;
};
class Base1 : virtual public BigBase{
public:
	Base1() :BigBase(10){} //不调用BigBase构造
};
class Base2 : virtual public BigBase{
public:
	Base2() :BigBase(10){} //不调用BigBase构造
};

class Derived : public Base1, public Base2{
public:
	Derived() :BigBase(10){} //调用BigBase构造
};
//每一次继承子类中都必须书写初始化语句
int main(){
	Derived derived;
	return EXIT_SUCCESS;
}

注意：
虚继承只能解决具备公共祖先的多继承所带来的二义性问题，不能解决没有公共祖先的多继承的.

程序员_小兵
关注
  • 20
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++类和对象---继承
m0_50046535的博客
04-15 652
继承是面向对象三大特性之一 1、继承的基本语法 语法： class 子类名 ：继承方式 父类名 子类 也叫 派生类 父类 也叫 基类 class basepage { public: void header() { cout << "首页，公开课、登录、注册..." << endl; } void footer() { cout << "帮助、交流、地图..." << endl; } void left() { cou
代码讲解C++继承和派生
12-31
继承是是指一个对象直接使用另一对象的属性和方法。 继承的作用： 1.描述客观事物的层次结构 2.分类的方法进行分析和描述 3.复杂的系统层次化，提高代码的重用性 4.增强语言功能，提高软件开发效益 继承分为单...
【C++】类与对象（四）：继承和派生
来日浅谈的博客
05-15 515
【C++】类与对象（四）：继承和派生1. 继承概述2. 派生类访问控制3. 继承中的构造和析构3.1 继承中的对象模型3.2 对象构造和析构的调用原则4. 继承中同名成员的处理方法5. 非自动继承的函数6. 继承中的静态成员特性(待更新)7. 多继承(待更新) 1. 继承概述 承是使代码可以复用的重要手段，也是面向对象程序设计的核心思想之一。简单的说，继承是指一个对象直接使用另一对象的属性和方法。...
C++类和对象的继承
03-17 743
在前面的章节，我们学会了如何编写一个完整的类。然而，面向对象的优势还没有被完全体现出来。特别是在编写一些相似的类时，可能会造成很多的浪费。本章就将以一个文字游戏为例，向大家介绍类的继承问题。 剑士·弓箭手·法师的困惑 在一个角色扮演类游戏（RPG）中，可能有各种不同职业的玩家，比如剑士、弓箭手和法师。虽然他们的职业不同，却有着一些相似之处：他们都具有生命值（Health Point——HP）、
类的继承和派生
a54010的博客
08-04 257
1、c++类的继承和派生机制 继承指的是从先辈出得到属性和行为的特征，也就是新类从已有的类那里得到已有的特性，反过来看，从已有类产生新类的过程就是类的派生。因此类的继承和派生是一个成对出现的概念，原来的类称为基类或者父类，产生的新类称为派生类或者子类，派生类同样可以作为基类派生新的类，这样就可以建立一个具有共同特性的对象家族，实现代码的重用。派生新类的过程一般包括，吸收父类的成员，调整...
【贪玩巴斯】c++核心编程，你需要敲出这些程序 ！（六）{继承 的详解！} //2021-05-03
D16100的博客
05-03 280
// // main.cpp // _day6 // // Created by AchesonD16 贪玩巴斯on 2021/4/23. // //继承 //继承是面向对象三大特性之一 // //有些类与类之间存在特殊的关系，例如： //我们发现，定义这些类时，下一级别的成员除了拥有上一级的共性，并且还拥有自己的特性 //这个时候我们可以考虑利用继承的技术，减少重复代码 1、继承的基本语法 //例如我们看到的很多网站中，都有公...
c++继承和派生.doc
01-13
C++中的继承和派生是面向对象编程的重要概念，它们允许创建新的类（派生类）基于现有的类（基类），从而实现代码的重用和类的层次结构。以下是关于继承和派生的详细说明： 12.1 继承的基本概念 继承是一种“is-a”...
派生类与继承
candyliuxj
09-26 8061
一、引入继承的目的  1. 代码重用         类的继承和派生机制，使程序员无需修改已有类，只需在已有类的基础上，通过增加少量代码或修改少量代码的方法得到新的类，从而较好地解决了代码重用的问题。 2. 代码的扩充         只有在派生类中通过添加新的成员，加入新的功能，类的派生才有实际意义。 二、派生类的声明格式（单继承） class 派生类名：继承方式 基类名 {
C++类和对象-继承
u011618818的博客
07-09 125
文章目录概述继承的基本语法继承方式 概述 当我们在定义类的时候类与类之间可能存在某些共性这些共性是可以通过继承被传承给下一个类的，我们将其称为继承，使用其技术可以减少重复的代码，提高类之间的关系性 继承的基本语法 语法格式: class 子类 : 继承方式 父类 {} class BaseClass { public: init() { cout<<"初始化"<<endl; } } class MyClas : public BaseClass { public:
c++ 类和对象之继承
weixin_62688907的博客
07-21 219
private成员在派生类中无论以怎样方式继承都不可见。如果基类成员不想在类外被直接访问，但是需要在派生类中访问，就定义为protected。保护限定符是因为继承才出现的。基类的其他成员在子类的访问方式==Min（成员的基类访问限定符，继承方式），public>protected>private使用关键字class时默认继承方式为private，struct为public。实际运用中一般都是public继承，几乎很少使用protected/private继承。...
C++类和对象——继承
KevinJune的博客
05-06 786
继承是面向对象三大特性之一 有些类与类之间存在特殊的关系，例如下图中： 我们发现，定义这些类时，下级别的成员出了拥有上一级的共性，还有自己的特性。这个时候我们就可以考虑利用继承的技术，减少重复代码。 1 继承的基本语法 例如我们看到很多网站中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同。接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义及好处。 #include<iostream> using namespace st...
C++:类和对象（继承）
LWJWJL00的博客
07-08 497
一个类除了拥有另一个类的共性，还有自己的特性，可以使用继承，减少重复代码 基本语法：class 子类 : 继承方式（public、protect、private） 父类 子类也称派生类，父类也称基类
C++【类与对象】——继承
憨憨冲鸭
04-28 1097
黑马视频课（127-134） C++【类与对象】之继承内容串讲，内容包括以下八个方面：基本语法：class 子类 : 继承方式 父类；继承方式：public、protected、privtae继承，重点记忆上述继承后成员属性访问权限的变化规律；继承中的对象模型：可以利用代码cl /d1 reportSingleClassLayout类名 ".cpp文件名"查看编程中某定义类的内部布局；构造和析构顺序；同名成员处理：加作用域；同名静态成员处理：加作用域；多继承语法；菱形继承问题以及解决办法：虚继承。
类的继承与派生
tf_apologize的博客
11-13 1251
类的继承与派生 类的继承，是新的类从已有类那里得到已有的特性。从已有类产生新类的过程就是类的派生。   派生类的定义： class 派生类名:继承方式 基类名1, 继承方式 基类名2, ……, 继承方式 基类名n {          派生类成员声明; };         一个派生类，可以同时有多个基类，这种情况称为多继承。这时的派生类同时得到了多个已有类的特性。一个派生
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值