c++详解【继承】

最新推荐文章于 2024-05-23 14:18:16 发布
最新推荐文章于 2024-05-23 14:18:16 发布
阅读量424 收藏 2
点赞数 1
分类专栏： c++ 文章标签： 继承
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxpresent/article/details/52901016
版权

学过c++的人都知道，c++的三大特性：封装、继承、多态。

我们今天说的是c++的继承，那么为什么要引入继承，它有什么特点呢？

首先，继承的特点是：使代码复用，为后面学习多态做铺垫。

继承分为：私有继承（private）、公有继承（public）、保护继承（protected）。

分别举例介绍一下它们各自的特性吧：

一、继承

私有继承：

//Inherit.h

#pragma once
#include<iostream>
using namespace std;

class Base
{
public:
	Base()
	{}
	void FunTest()
	{
		cout<<_pri<<endl;
	}
	int _pub;
protected:
	int _pro;
private:
	int _pri;
};

class Derived:private Base         //私有继承基类Base
{
public:
	Derived()
	{}
	void Function()
	{
		cout<<_pub<<endl;
	}
private:
	int _d;
};
//Inherit.cpp 

#include"Inherit.h"

int main()
{
	Base b;
	Derived d;
	d._pri = 10;         //error
	d._pro = 20;         //error
	d._pub = 30;         //error
	d.Function();
	return 0;
}

通常我们把继承自基类的类称为派生类。

运行结果：


由上述结果可知，对于私有继承下的派生类来说，在基类中的公有成员及成员函数继承到派生类就变为私有，基类的保护也变为派生的私有，基类的私有则不继承下去。当然私有继承下的派生类中的成员及成员函数不能在类外被访问。

保护继承：

//Inherit.h

#pragma once
#include<iostream>
using namespace std;

class Base
{
public:
	Base()
	{}
	void FunTest()
	{
		cout<<_pri<<endl;
	}
	int _pub;
protected:
	int _pro;
private:
	int _pri;
};

class Derived:protected Base
{
public:
	Derived()
	{}
	void Function()
	{
		cout<<_pub<<endl;
	}
private:
	int _d;
};

class Third:protected Derived
{
public:
	void F()
	{
		cout<<_pub<<endl;
	}
private:
	int _third;
};
//Inherit.cpp 

#include"Inherit.h"

int main()
{
	Base b;
	Derived d;
	Third t;
	d._pri = 10;        //error
	d._pro = 20;        //error
	d._pub = 30;        //error
	d.Function();
	t.F();
	return 0;
}

运行结果：


由上述结果可知，对于保护继承下的派生类来说，在基类的公有成员及成员函数继承到派生类中就变为私有，基类的保护也变为派生的保护，基类的私有则不继承下去。此时如果变为保护，则在有继承关系的类与类之间可以互相访问，而在类外不可访问。

公有继承：

//Inherit.h

#pragma once
#include<iostream>
using namespace std;

class Base
{
public:
	Base()
	{}
	void FunTest()
	{
		cout<<_pri<<endl;
	}
	int _pub;
protected:
	int _pro;
private:
	int _pri;
};

class Derived:public Base
{
public:
	Derived()
	{}
	void Function()
	{
		cout<<_pub<<endl;
	}
private:
	int _d;
};

class Third:protected Derived
{
public:
	void F()
	{
		cout<<_pub<<endl;
		cout<<_pro<<endl;
	}
private:
	int _third;
};
//Inherit.cpp 

#include"Inherit.h"

int main()
{
	Base b;
	Derived d;
	Third t;
	d._pri = 10;           //error
	d._pro = 20;           //error
	d._pub = 30;
	d.Function();
	t.F();
	return 0;
}

运行结果：


由上述结果可知，对于公有继承下的派生类来说，在基类的公有成员及成员函数继承到派生类中仍为公有（即在类外也可访问），基类的保护也变为派生的保护，基类的私有则不继承下去。

下面拿一个表格来总结一下吧~


注：若类中省略以何种方式继承时，默认为私有继承。

二、调用顺序

例1：

//Inherit.h

#pragma once
#include<iostream>
using namespace std;
class Base
{
public:
	Base()
	{
		cout<<"Base()"<<endl;
	}
	~Base()
	{
		cout<<"~Base()"<<endl;
	}
private:
	int _b;
};

class Derived:public Base
{
public:
	Derived()
	{
		cout<<"Derived()"<<endl;
	}
	~Derived()
	{
		cout<<"~Derived()"<<endl;
	}
private:
	int _d;
};
//Inherit.cpp 

#include"Inherit.h"
int main()
{
	Base b;
	Derived d;
	getchar();
	return 0;
}
运行结果：



调用顺序分析：

Base b;创建一个基类的对象b，则调用基类的构造函数；Derived d;创建一个派生类对象d，则调用派生类的构造函数，此时这里没有直接的调用派生类的构造函数，而是调用基类的构造函数，最后再调用派生类的构造函数。(在派生类对象调用构造函数时，是在派生类对象构造函数的初始化列表中调用了基类的构造函数)

如派生类构造函数原型为：

	Derived()
		:Base()
	{
		cout<<"Derived()"<<endl;
	}
例2：

//Inherit.h

#pragma once
#include<iostream>
using namespace std;

class Base
{
public:
	Base()
	{
		cout<<"Base()"<<endl;
	}
	~Base()
	{
		cout<<"~Base()"<<endl;
	}
private:
	int _b;
};

class C
{
public:
	C()
	{
		cout<<"C()"<<endl;
	}
	~C()
	{
		cout<<"~C()"<<endl;
	}
};
class Derived:public Base
{
public:
	Derived()
		:Base()
	{
		cout<<"Derived()"<<endl;
	}
	~Derived()
	{
		cout<<"~Derived()"<<endl;
	}
private:
	C _c;
};
//Inherit.cpp 

#include"Inherit.h"
int main()
{
	Base b;
	Derived d;
	getchar();
	return 0;
}
运行结果：



构造函数的调用次序：

初始化列表的构造函数-->成员变量的构造函数-->派生类的构造函数

三、继承体系的作用域

要知道，继承体系中基类和派生类是在两个不同的作用域中。

类中有很多函数，那么当基类的成员函数和派生类的成员函数同名了怎么办呢？它会调用哪个函数呢？

例：

//Inherit.h

#pragma once
#include<iostream>
using namespace std;
class Base
{
public:
	Base()
	{}
	void Fun()
	{
		cout<<"Base::Fun()"<<endl;
	}
protected:
	int _b;
};


class Derived
{
public:
	Derived()
	{}
	void Fun()
	{
		cout<<"Derived::Fun()"<<endl;
	}
private:
	int _d;
};
//Inherit.cpp 

#include"Inherit.h"
int main()
{
	Base b;
	Derived d;
	d.Fun();
	system("pause");
	return 0;
}
运行结果：



当用派生类的对象调用与基类同名的函数的时候，派生类会调用自己的成员函数。把基类的函数隐藏起来。这被称作同名隐藏。（只要函数名相同，就会出现同名隐藏）

四、赋值兼容规则

关于赋值，大家再熟悉不过了吧。有同一类型的赋值，有不同类型的赋值（可能会用到强制类型转换哦）。

这里，我们要掌握的是基类与派生类之间的赋值；

例：

1、派生类对象赋给基类对象；（切割、切片）

2、基类对象不能赋给派生类对象；

3、基类的指针或引用指向派生类对象；

4、派生类的指针或引用不能指向基类的对象。（可以通过强制类型转换完成）

例：

//Inherit.h

#pragma once
#include<iostream>
using namespace std;
class A
{
public:
	A()
	{
		cout<<"A()"<<endl;
	}
	int _a;
};

class B:public A
{
public:
	B()
	{
		cout<<"B()"<<endl;
	}
	int _b;
};

//Inherit.cpp 

#include"Inherit.h"
int main()
{
	A a;
	B b;
	a = b;
	b = a;       //error,无法将基类对象赋给派生类对象
	A *pA = NULL;
	B *pB = NULL;
	pA = pB;
	pB = pA;     //error，无法让派生类指针给<span style="font-family: Arial, Helvetica, sans-serif;">基</span><span style="font-family: Arial, Helvetica, sans-serif;">类指针</span>
	A &aa = b;
	B &bb = a;   //error,无法让派生类的引用给基类对象

	return 0;
}
上述错误的赋值和指向可以通过强制类型转化。

改：



五、几种不能继承的关系

1、友元关系不能继承。

2、对于静态成员及静态成员函数，则整个继承体系中只有一个这样的成员。无论派生出多少个子类，都只有一个这样的static成员实例。

例1：

//Inherit.h

#pragma once
#include<iostream>
using namespace std;
#include<string>
class Person
{
	friend void Display(Person &p,Student &s);
public:
	string p_name;
};
class Student:public Person
{
public:
	string s_no;
};

void Display(Person &p,Student &s)
{
	cout<<p.p_name<<endl;
	cout<<s.p_name<<endl;
	cout<<s.s_no<<endl;
}
//Inherit.cpp 

#include"Inherit.h"
int main()
{
	Person p;
	Student s;
	Display(p,s);           //error,无法识别Student
	return 0;
}

这里说明的就是友元关系不能继承。

例2：

//Inherit.h

#pragma once
#include<iostream>
using namespace std;
#include<string>
class Person
{
public:
	Person()
	{
		cout<<"Person()"<<endl;
		++_count;
	}
protected:
	string _name;
public:
	static int _count;
};

int Person::_count = 0;

class Student:public Person
{
protected:
	int _num;
};

class Graduate:public Student
{
protected:
	string _course;
};
//Inherit.cpp 

#include"Inherit.h"
int main()
{
	Student s;
	Graduate g;
	cout<<Person::_count<<endl;
	cout<<Student::_count<<endl;
	Student::_count = 0;
	cout<<Student::_count<<endl;
	cout<<Person::_count<<endl;
	return 0;
}
运行结果：


注：友元函数和static成员函数都没有this指针。

六、单继承&多继承

上述讲述的都是单继承的形式，那么多继承是什么样子的呢？

例：

class A
{
public:
	A()
	{}
protected:
	int _a;
};

class B
{
public:
	B()
	{}
protected:
	int _b;
};

class C:public A ,public B             //实现多继承，c既可以访问A类的公有和保护成员，也可以访问B类的公有和保护成员。
{
public:
	C()
	{}
protected:
	int _c;
}

七、菱形继承（也称钻石继承）

形如：



代码如下：

Inherit.h

#pragma once
#include<iostream>
using namespace std;
class B
{
public:
	B()
	{}
protected:
	int _b;
};
class C1:public B
{
public:
	C1()
	{}
protected:
	int _c1;
};

class C2:public B
{
public:
	C2()
	{}
protected:
	int _c2;
};

class D:public C1,public C2
{
public:
	D()
	{}
private:
	int _d;
};

Inherit.cpp

#include"Inherit.h"
int main()
{
	B b;
	C1 c1;
	C2 c2;
	D d;
	cout<<sizeof(B)<<endl;           //打印类B中成员，所以它的size为4
	cout<<sizeof(C1)<<endl;          //打印类C1中的成员，并且继承了类B，所以它的size为8
	cout<<sizeof(C2)<<endl;          //打印类C2中的成员，并且继承了类B，所以它的size为8
	cout<<sizeof(D)<<endl;           //打印类D的成员，并且继承了类C1，C2，所以它的size为20
	return 0;
}
运行结果：



内存中是这样的形式出现的：



八、虚继承

为了解决菱形继承的二义性问题，又引出了虚继承的概念。在内存中添加了一个地址，用来存放偏移量。虽然浪费了空间，但是解决了二义性问题。

就如上述菱形继承一样，通常，我们在用D d；创建一个对象之后，用派生类的对象调用基类的成员时，不知道到底是C1还是C2继承下来的成员，这时就会出现二义性。为了解决上述问题的二义性，我们引出了虚继承。

例：

Inherit.h

class B
{
public:
	B()
	{}
protected:
	int _b;
};

class C1:virtual public B
{
public:
	C1()
	{}
protected:
	int _c1;
};

class C2:virtual public B
{
public:
	C2()
	{}
protected:
	int _c2;
};

class D:public C1,public C2
{
public:
	D()
	{}
private:
	int _d;
};

Inherit.cpp

int main()
{
     B b;
     C1 c1;
     C2 c2;
     D d;
     cout<<sizeof(B)<<endl;  //只有一个成员，所以size为4
     cout<<sizeof(C1)<<endl; //类C1自己的成员和继承自B的成员，还有一个存放偏移量的虚地址，size为12
     cout<<sizeof(C2)<<endl; //类C2自己的成员和继承自B的成员，还有一个存放偏移量的虚地址，size为12
     cout<<sizeof(D)<<endl;  //继承自C1，C2，所以size为24
     return 0;
}
运行结果：



形式如图所示：



继承的内容就先说到这里啦，讲的不详细的还希望大家能给出建议哦。

欢迎大家来访~~吐舌头吐舌头






xxpresent
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
c++继承【全网最详细讲解】
qq_54626677的博客
02-02 596
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。
【C++】继承详解
love_guanghui的博客
02-24 1478
继承继承的概念及定义概念定义基类和派生类基类和派生类对象的赋值类型转换继承中的作用域 本文将介绍C++面向对象中三大特性之一的继承，并详细介绍多继承引发的菱形继承及其解决方法。 继承的概念及定义 概念 就像现实世界中子辈继承父辈遗产一样，面向对象的语言一样有继承，这是面向对象程序设计使代码可以复用的最重要的手段。 举个例子，老师和学生都是人，都有人的属性，有姓名，年龄，性别等等公共属性，而如果设计这些对象时在类中都定义相关变量，就会造成数据冗余。所以我们可以将这些共同属性统一为一个类Person，再让St
C++继承[万字详解]
weixin_47257473的博客
03-16 3761
本文非常详细介绍了C++中的继承，包括继承的定义，介绍，方式。以及继承后派生类构造函数和析构函数的调用顺序，继承中的切片等问题，继承后静态成员，友元关系的变化，以及多继承中的菱形继承和菱形虚拟继承，对继承的一些总结。继承和组合的介绍以及关系.
C++中的继承 详细讲解
最新发布
foodsx的博客
05-23 1616
C++中的继承 详细讲解
C++之继承详解(万字讲解)
be_a_struggler的博客
11-11 6099
C++继承详解，继承概念与定义，六大默认函数，基类和派生类赋值转换，继承中的作用域，继承与友元，继承与静态成员，菱形虚拟继承，菱形继承，菱形继承的深度剖析
c++：继承（超详解）
热门推荐
qq_62718027的博客
07-22 7万+
目录一：什么是继承二：继承的格式继承的总结：二：子类和父类（基类和派生类）1.子类和父类的相互赋值：2.同名的成员变量3.同名成员函数三：子类中默认的成员函数1.构造函数2.析构函数3.拷贝构造4.赋值运算符重载 四：单继承和多继承单继承： 多继承：菱形继承解决方法一：解决方法二：单继承和多继承的总结：定义：继承(inheritance)机制是面向对象程序设计中使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生的新类，称派生类（或子类），被继承的类称基类（或父类）
C++ 继承详解
Hxbupaixu的博客
11-25 4577
我们定义了一个Student的派生类,也被称为子类。Person是基类,也被称为父类。继承属于C++学习的一个难关,限于笔者能力有限,如有错误,请读者进行指正!
C++继承详解
liuming
10-21 252
@[TOC]继承详解 继承的概念 继承机制是面向对象程序设计使代码复用最重要的手段，它允许程序员在保持原有类特性上进行扩展，增加功能，这样产生新的类称为派生类（子类），继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。 简单理解就是：就像儿子继承父亲的资产一样，既有了父类原有的属性和功能由新增了自己的属性和功能即产生了子类（派生类）。 继承方式 class Base{} class Derived:继承权限 Base{} 继承权限 pubilc、protected、private 作用：
详解c++ 继承
08-18
详解 C++ 继承 C++ 继承是面向对象程序设计中最重要的一个概念。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。当创建一个...
C++ 继承详解及实例代码
12-31
C++继承可以是单一继承或多重继承，每一个继承连接可以是public,protected,private也可以是virtual或non-virtual。然后是各个成员函数选项可以是virtual或non-virtual或pure virtual。本文仅仅作出一些关键点的验证...
C++类继承内存布局详解图（一目了然）
07-24
看了这个内存布局图详解之后，对于C++的了解更加深刻了，之前不懂得一头雾水的东西全都清楚了。
C++之继承最详讲
weixin_45897952的博客
05-02 5605
目录 1.继承的概念 2.继承的定义 3.继承权限 3.1、子类以public方式继承父类 3.2、子类以protect方式继承 3.3、子类以private方式继承 3.4、class关键字没有给出继承方式默认的继承方式是私有的继承方式 3.5、struct关键字没有给出继承方式默认的继承方式是公共的继承方式 3.6、那么我们可以就此总结一下class和struct的区别 3.7、关于继承方式大总结 4.基类和派生类对象赋值转换 4.1、派生类对象可以赋..
【C++】详解继承
Hush_H的博客
06-27 354
详解继承及多继承，菱形继承及菱形虚拟继承
C++的protected
图像学习之旅
02-01 3331
基类成员在派生类中的访问权限不得高于继承方式中指定的权限。例如，当继承方式为 protected 时，那么基类成员在派生类中的访问权限最高也为 protected，高于 protected 的会降级为 protected，但低于 protected 不会升级。再如，当继承方式为 public 时，那么基类成员在派生类中的访问权限将保持不变。 也就是说，继承方式中的 public、protected、private 是用来指明基类成员在派生类中的最高访问权限的。 2) 不管继承方式如何，基类中的 privat
C++ 继承
weixin_53946312的博客
10-18 276
继承继承继承概念继承定义定义格式继承关系和访问限定符继承基类成员访问方式的变化基类和派生类对象赋值转换 继承 继承概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 继承定义 定义格式 继承关系和访问限定符 继承基类成员访问方式的变化 总结 基类private成
C++中继承 —— 继承的概念及定义
XHumble的博客
06-20 1550
继承的概念及定义： 继承是面向对象程序设计使代码可以复用的最重要的手段，允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生的新类，称为派生类。 继承呈现了面向对象程序设计的层次结构，体现了有简单到复杂的认知过程，以前我们接触的复用都是函数复用，继承使类设计层次的复用。 #include <iostream> using namespace std; #include <string> // 人 class Person { public: void Set.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值