c++详解【继承】

学过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;         //errord._pro = 20;         //errord._pub = 30;         //errord.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;        //errord._pro = 20;        //errord._pub = 30;        //errord.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;           //errord._pro = 20;           //errord._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,无法识别Studentreturn 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为4cout<<sizeof(C1)<<endl;          //打印类C1中的成员，并且继承了类B，所以它的size为8cout<<sizeof(C2)<<endl;          //打印类C2中的成员，并且继承了类B，所以它的size为8cout<<sizeof(D)<<endl;           //打印类D的成员，并且继承了类C1，C2，所以它的size为20return 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为4cout<<sizeof(C1)<<endl; //类C1自己的成员和继承自B的成员，还有一个存放偏移量的虚地址，size为12cout<<sizeof(C2)<<endl; //类C2自己的成员和继承自B的成员，还有一个存放偏移量的虚地址，size为12cout<<sizeof(D)<<endl;  //继承自C1，C2，所以size为24return 0;
}
运行结果：



形式如图所示：



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

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






本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/382811.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【送给Git初学者】

【送给Git初学者】

好多人都听过Git吧&#xff0c;目前最流行的分布式版本管理系统。还有好多类似的cvs、svn&#xff08;速度慢、必须联网&#xff0c;这些是集中式版本控制系统&#xff09;..... 那么&#xff0c;它是用来干什么的呢&#xff1f;举个例子可能更好理解吧&#xff01; 比如你写…
阅读更多...
远程仓库

远程仓库

上节我们安装好了git&#xff0c;并配置好git&#xff0c;github之间的ssh。这节我们就开始用git管理我们的仓库吧。&#xff08;这节在windows下安装的git bash上给大家演示吧&#xff09; 首先&#xff0c;创建好一个仓库&#xff0c;主要步骤如下&#xff1a; 创建好仓库后…
阅读更多...
linux根目录的意义和内容

linux根目录的意义和内容

1.du命令&#xff1a;du [选项] 文件     (1)功能该命令是显示指定文件以及下的所有文件占用系统数据块的情况&#xff0c;如果没有文件&#xff0c;默认为是当前工作目录     -a    显示所有文件对系统数据块的使用情况     -b    显示数据块大小时以字节…
阅读更多...
c++详解【智能指针】

c++详解【智能指针】

智能指针&#xff1f;是一个指针吗&#xff1f;这里给大家说的是&#xff0c;它不是一个指针&#xff0c;但它模拟了指针所具有的功能。那么&#xff0c;为什么要有智能指针的引入呢&#xff1f;看看下面的例子吧~ void FunTest() {int *p new int[10];FILE *pFile fopen(&qu…
阅读更多...
c++【深度剖析shared_ptr】

c++【深度剖析shared_ptr】

shared_ptr解决了scoped_ptr管理单个对象的缺陷&#xff0c;且解决了防拷贝的问题。shared_ptr可以管理多个对象&#xff0c;并且实现了资源共享。 但是仍然存在一些问题&#xff0c;比如&#xff0c;我们熟悉的双向链表&#xff1a; struct Node { Node(const int& value…
阅读更多...
c++详解【new和delete】

c++详解【new和delete】

说起new和delete&#xff0c;了解过c的人应该都知道吧&#xff0c;它是用来分配内存和释放内存的两个操作符。与c语言中的malloc和free类似。 c语言中使用malloc/calloc/realloc/free进行动态内存分配&#xff0c;malloc/calloc/realloc用来在堆上分配空间&#xff0c;free将申…
阅读更多...
Stack/Queue与Vector/List的联系

Stack/Queue与Vector/List的联系

Vector:(顺序表【数组存储】) 1.当申请的空间不足的时候&#xff0c;需要再次开辟一块更大的空间&#xff0c;并把值拷过去。 2.对于尾删和尾插是比较方便的&#xff0c;只需要改动最后一个元素即可。不会改动原有的空间。适用于多次重复的对尾部插删。 3.顺序存储&#xff…
阅读更多...
用栈实现后缀表达式求解问题

用栈实现后缀表达式求解问题

一、问题概述&#xff1a; 人们经常书写的数学表达式属于中缀表达式&#xff0c;今天要解决的是&#xff0c;后缀表达式的求解问题。 如下图分别为举例的中缀表达式和后缀表达式&#xff1a; 二、解决思路 我们用栈存储后缀表达式中的数据部分&#xff0c;当遇到操作符时就取…
阅读更多...
用栈和递归求解迷宫问题

用栈和递归求解迷宫问题

一、问题概述 小时候&#xff0c;我们都玩过走迷宫的游戏吧。看一下这个图例&#xff1a; 遇到这种问题时&#xff0c;我们第一反应都会先找到迷宫的入口点&#xff0c;然后对上下左右四个方向进行寻迹&#xff0c; 检测当前位置是否是通路&#xff0c;是否可以通过&#xff0…
阅读更多...
【c语言】棋盘游戏--三子棋

【c语言】棋盘游戏--三子棋

一、问题概述 大家都玩过棋盘游戏吧&#xff0c;像五子棋一样&#xff0c;玩家或者是电脑一人下一次&#xff0c;当玩家或者是电脑的某一方先将各自的五个棋子下成一条线时&#xff0c;谁就赢&#xff0c;棋盘游戏就会结束。 当然&#xff0c;我今天要介绍的是三子棋&#xff…
阅读更多...
[数据结构]求解迷宫最短路径问题

[数据结构]求解迷宫最短路径问题

一、问题概述 之前&#xff0c;我们了解了如何实现迷宫问题&#xff08;对于迷宫只有一个出口可以通的情况&#xff09;&#xff0c;事实上我们的迷宫有多个出口&#xff0c;对于每条路径来说&#xff0c;有长有短&#xff0c;所以在这里&#xff0c;我们讨论一下迷宫的最短路…
阅读更多...
[STL]List的实现

[STL]List的实现

STL&#xff08;Standard template Library&#xff09;:c的标准模板库 STL是算法和数据结构的软件框架&#xff0c;它包含了六大组件&#xff1a;算法、迭代器、容器、仿函数、配接器、空间配置器。 迭代器&#xff1a;我们可以把迭代器相当于智能指针&#xff0c;&#xff0…
阅读更多...
vc++6.0的应用程序打不开肿么办

vc++6.0的应用程序打不开肿么办

今天早起&#xff0c;有同学问到我关于vc6.0的安装过程中遇到的问题&#xff0c;我听了之后想想还是写篇博客给大家看一下吧。因为我之前也遇到过类似的问题。当时也是挺着急的。 大家遇到的问题估计就是这样吧~~&#xff08;下载后打不开&#xff09; 请看-->解决步骤&…
阅读更多...
【数据结构】广义表

【数据结构】广义表

一、问题概述 广义表是非线性的数据结构&#xff0c;是由若干个元素组合而成的&#xff0c;广义表中可以有子表&#xff0c;类似这样的&#xff1a; 我们以C(a,b,(c,d))为例&#xff0c;将它定义为这样的数据结构&#xff1a; 我们会给定字符串的形式&#xff0c;如&#xff…
阅读更多...
【数据结构】普通二叉树的实现

【数据结构】普通二叉树的实现

一、问题概述 树是n个有限个数据的集合&#xff0c;形如&#xff1a; 它像不像倒着的树呢&#xff1f;我们把它看成是一种数据结构----树。它的第一个节点称作树的根&#xff0c;最底下的那些节点称作树的叶子。 我们今天所要研究的是二叉树&#xff0c;即父节点最多只有两个孩…
阅读更多...
setitimer用法说明

setitimer用法说明

函数原型&#xff1a; int setitimer(int which, const struct itimerval *new_value,struct itimerval *old_value) 函数作用&#xff1a; 可用来实现延时和定时的功能 头文件&#xff1a; #include <sys/time.h> 参数详解 用一把&#xff1a;一个例子 #include &…
阅读更多...
哈希表（闭散列、拉链法--哈希桶）

哈希表（闭散列、拉链法--哈希桶）

哈希表&#xff0c;也称散列表&#xff0c;是一种通过key值来直接访问在内存中的存储的数据结构。它通过一个关键值的函数&#xff08;被称为散列函数&#xff09;将所需的数据映射到表中的位置来访问数据。 关于哈希表&#xff0c;主要为以下几个方面&#xff1a; 一、哈希表…
阅读更多...
僵尸进程的产生和SIGCHLD信号

僵尸进程的产生和SIGCHLD信号

核心句子 子进程在终止时会给父进程发SIGCHLD信号,该信号的默认处理动作是忽略,父进程可以自 定义SIGCHLD信号的处理函数。 僵尸进程的产生&#xff1a; #include "head.h" #include <unistd.h> #include <signal.h>int main() {key_t key ftok(&quo…
阅读更多...
海量数据处理--位图（BitMap）

海量数据处理--位图（BitMap）

对于海量数据这个词&#xff0c;大家不难理解吧。主要是针对给定的数据量特别大&#xff0c;占用内存特别大的情况。那么和位图有什么关系呢。看下面一个腾讯的海量数据的例子吧。 例&#xff1a;给40亿个不重复的无符号整数&#xff0c;没排过序。给一个无符号整数&#xff0…
阅读更多...
ps命令与top命令参数意义详解

ps命令与top命令参数意义详解

文章目录1.ps -l2.ps aux3.top面试经常被问道&#xff0c;特别是top。1.ps -l 参数解释F代表这个程序旗标 (process flags)&#xff0c;说明这个程序的总结权限&#xff0c;常见号码有&#xff1a;o 若为 4 表示此程序的权限为 root &#xff1b;o 若为 1 则表示此子程序仅进行…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023