c++的继承 《进阶一》 《继承的概念》《继承的定义》《继承基类成员访问方式的变化》《继承的中的作用域》《派生类的默认成员函数》《继承和友元》

最新推荐文章于 2022-04-06 09:28:36 发布
最新推荐文章于 2022-04-06 09:28:36 发布
阅读量305 收藏
点赞数
分类专栏： c++的进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dpfxaca6/article/details/88676853
版权

我相信，如果当你点开这篇博客，说明你已经进入了c++的部分了，如果是刚刚开始学习继承的同学，我建议还是先看一下，我写的类和对象，先要了解一下，这里是进阶部分，害怕直接看同学有一点看懂。这节内容有一点多，所以我准备分两次写 ，我会把链接放在下面
c++的继承 《进阶二》：https://blog.csdn.net/dpfxaca6/article/details/88784387
类和对象：https://blog.csdn.net/dpfxaca6/article/details/86511762
好了，还是直接进入我的学习继承进阶的部分
一. 《继承的概念及定义》
(1) 继承的概念;
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。
下面看一下代码的实现：

#include<iostream>
#include<string>   //再写的时候，一定要使用这个接口，因为调用了String关键字。
using namespace std;
//父类
class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "peter"; // 姓名
	int _age = 18; // 年龄
};
//子类
class Student : public Person
{
protected:
	int _stuid; // 学号
};

class Teacher : public Person
{
protected:
	int _jobid; // 工号
};
 //继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分
// Student和Teacher复用了Person的成员。下面我们使用监视窗口查看Student和Teacher对象，
//可以看到变量的复用。调用Print可以看到成员函数的复用。
int main()
{
	Student s;
	Teacher t;
	s.Print();
	t.Print();
	return 0;
}

下面是执行代码：
在这里插入图片描述
这样我们就可以清楚的看出了我们所写的程序，在子类中，可以调用父类的函数复用，这就是我们上面提到过的继承是类设计层次的复用，所以，我们应该还好理解其中的意思。
（2） 继承的定义
1-定义格式
下面我们看到Person是父类，也称作基类。Student是子类，也称作派生类。
在这里插入图片描述
由上面的图片：我相信我们了解开始写的**《基类》父类和《派生类》子类**了吧
2- 继承关系和访问限定符

我们都知道继承和访问限定符都是有三种关系;
在这里插入图片描述
在这里插入图片描述
3-继承基类成员访问方式的变化
在这里插入图片描述如果有什么问题，可以先了解以下，我写的类和对象：
https://mp.csdn.net/mdeditor/86511762#

为什么会是这样；我们用代码来实现以下，先了解以下，后面我会总结一下。

#include<iostream>
#include<string>

using namespace std;

class Person
{
public:
	void Print()
	{
		cout << _name << "peter"<< endl;
	}
protected:
	string _name; // 姓名
private:
	int _age; // 年龄
};

//class Student : protected Person    //夫类公共，子类保护，子类就不能直接访问父类就访问不了；父类可以访问自己
//class Student : public Person    //公共和公共就可以直接 子在夫中直接调用；
class Student : private Person    //夫类公共，子类私有，在调用的时候也是不能直接被访问的。
{
protected:
	int _stunum; // 学号
};

int main()
{
	Person p;
	p.Print();
	Student s;
	s.Print();
	return 0;
}

根据上面的代码，我们可以了解掉，在父类和子类使用不同的访问限定符的时候，其调用的结果也是不一样。
在这里插入图片描述当你调用使用在子类不同的调用方式的时候，结果就是这个样子。
**总结：

  1. 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。

  2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

  3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。

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

  5. 在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用
    protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中
    扩展维护性不强**。
    所以建议大家不要是用保护《protected》或者私有《private》，大部分直接使用的就是共有《public》。
    二，基类和派生类的对象的赋值转换

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

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

    int main()
    {
    Student s; // 1.子类对象可以赋值给父类对象/指针/引用
    Person p = s;
    Person* pp = &p; // 在这里需要将取地址符加上，要不然无法有 person 转化成 person*；
    //s = p; //2.无法赋值由基类直接到派生类；
    // 3.基类的指针可以通过强制类型转换赋值给派生类的指针
    pp = &s;
    Student* s1 = (Student*)pp;
    s1->_No = 10;
    //这种情况下面是可以转换，并且可以通过编译，而且程序可以执行。在这里插入图片描述
    在这里插入图片描述
    pp = &p;
    Student* s2 = (Student*)pp;
    s2->_No = 10;
    //这种情况下是可以转换，而且编译可以通过，但是程序不可以执行，直接崩掉，访问越界；在这里插入图片描述
    在这里插入图片描述
    return 0;
    }

以上是因为要看图片比较多，所以看起来有一点乱，所以希望有什么意见的同学，提一下意见。

三，继承的中的作用域

#include<iostream>
#include<string>

using namespace std;

class Person
{
protected:
	string _name = "小李子"; // 姓名
	int _num = 111; // 身份证号
};
class Student : public Person
{
public:
	void Print()
	{
		cout << " 姓名:" << _name << endl;
		//cout << " 身份证号:" << _num << endl;     //1.当子类与父类的里面有同名成员，调用子类，将父类直接隐藏。
		cout << " 身份证号:" <<Preson::_num << endl;  修改方法；在——num前面加上父类的名；
		cout << " 学号:" << _num << endl;
	}
protected:
	int _num = 999; // 学号  
};

int main()
{
	Student s1;
	s1.Print();
	return 0;
}

// B中的fun和A中的fun不是构成重载，因为不是在同一作用域
// B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。
class A
{
public:
void fun()
{
cout << “func()” << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
A::fun();
cout << “func(int i)->” <<i<<endl;
}
};
int main()
{
B b; //1. 调用的第一次
b.fun(10);
A a; //2. 调用的第二次
a.fun();
B b;
b.fun(10);
}

调用这两次的结果是不一样，看一下下面的图片：
在这里插入图片描述第一次调用。

在这里插入图片描述第二次调用。

总结以下：

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

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

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

6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个
成员函数是如何生成的呢？
1. 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
2. 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
3. 派生类的operator=必须要调用基类的operator=完成基类的复制。
4. 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理派生类成员再清理基类成员的顺序。
5. 派生类对象初始化先调用基类构造再调派生类构造。
6. 派生类对象析构清理先调用派生类析构再调基类的析构。
下面有详细的介绍，请看下面的代码；

 #include<iostream>
    using namespace std;
    
     class Person
    {
    public:
    	Person(const char* name = "peter")
    		: _name(name)
    	{
    		cout << "Person()" << endl;
    	}
    	Person(const Person& p)
    		: _name(p._name)
    	{
    		cout << "Person(const Person& p)" << endl;
    	}
    	Person& operator=(const Person& p)
    	{
    		cout << "Person operator=(const Person& p)" << endl;
    		if (this != &p)
    			_name = p._name;
    		return *this;
    	}
    	~Person()     //派生类的析构必须调用基类的析构
    	{
    		cout << "~Person()" << endl;
    	}
    protected:
    	string _name; // 姓名
    };




class Student : public Person
    {
    public:
    	Student(const char* name, int num)
    		: Person(name)
    		, _num(num)
    	{
    		cout << "Student()" << endl;
    	}
    	Student(const Student& s)
    		: Person(s)
    		, _num(s._num)
    	{
    		cout << "Student(const Student& s)" << endl;
    	}
    	Student& operator = (const Student& s)
    	{
    		cout << "Student& operator= (const Student& s)" << endl;
    		if (this != &s)
    		{
    			Person::operator =(s);
    			_num = s._num;
    		}
    		return *this;
    	}
    	~Student()
    	{
    		cout << "~Student()" << endl;
    	}
    protected:
    	int _num; //学号
    };
    void Test()
    {
    	Student s1("jack",18);
    	Student s2(s1);
    	//Student s3("rose", 17);
    	//s1 = s3;
    }

    
    int main()
    {
    	Test();
    	return 0;
    }

<不知道怎么回事，我们上面是代码，不可以弄成代码块>。来看下面的图篇让我们分析一下上面的话：
在这里插入图片描述这是当全部打开的时候，基类和派生类都没有关闭，全部调用，
在这里插入图片描述
这个是将基类的构造函数屏蔽掉，导致程序崩溃，这就明白了，派生类调用的构造函数是由基类提供的。
这里差两个图片，回去补上。

那么，这里又有一个问题，怎么实现一个不被继承的类？？？

这里就要说一个关键字 “ final ”，它是如何使用的呢？
这里我就不举例子了，就拿上面的例子说明一下：
在：class Person 后面加上 final

在这里插入图片描述
这样就可以实现一个不被继承的类，虽然我们使用类的时候，肯定是要被继承的，但不排除特殊情况。

五。继承和友元
友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员 看下面的代码：

  **#include<iostream>
    #include<string.h>
    using namespace std;**


class Person
{
public:
	friend void Display(const Person& p, const Student& s);
public:
	string _name; // 姓名
};

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

void Display(const Person& p, const Student& s)
{
	cout <<  p._name << endl;
	cout <<  s._stuNum << endl;
}

void Test()
{
	Person p;
	Student s;
	Display(p, s);
}

int main()
{
	Test();
	return 0;
}

直接调用这给函数会有一点问题。
实际因为是因为;基类的友元不能访问子类私有和保护成员

c++的继承 《进阶二》：https://mp.csdn.net/mdeditor/88784387#
类和对象：https://mp.csdn.net/mdeditor/86511762#

清华大学C++进阶讲义：第7章类的继承.pdf
01-22
包括继承与派生的基本概念、单继承与多继承、类成员的访问控制、派生类对象的构造和析构、派生类与基类对象的类型转换、类成员的标识与访问、虚继承等内容，为读者提供了一个系统的了解C++语言中类继承的知识体系。
派生类对基类成员的访问权限
最新发布
chenyu_Yang的博客
12-22 925
public继承时，派生类成员可以访问基类的public，和protected成员，但是不可以访问private成员，此时基类的public成员就相当于变成了派生类的public成员，protected成员变成了派生类的protected成员，而private成员则变成了派生类不可访问的成员。派生类对象只能直接访问通过public继承的基类的public成员，除此之外无法直接访问其他类型继承的基类成员和public继承的其他类型成员。1，首先讲解一下派生类成员对基类成员的访问权限。
基类和派生类的成员访问
lidanny的专栏
05-26 4990
#include using namespace std; class Cbase { public:     Cbase(int x = 0, int y = 0, int z = 0):a(x), b(y), c(z){};     voi
java派生_Java基类和派生类
weixin_32742673的博客
02-12 4232
从外部看来，派生类是一个与基类具有相同接口的新类，或许还会有一些额外的的方法和域 。但继承并不仅仅是类的复用。当创建了一个派生类的对象时，该类包含了一个基类的子对象。这个子对象和你用基类直接创建的对象没有什么两样。二者的区别在于，后者来自于外部，而基类的子对象来自于派生类对象的内部。对基类的子对象初始化时至关重要的，而且也只有一种方法来保证这一点，那就是在派生类的构造器中调用基类的构造器，而基类的...
基类和派生类之间的同名函数，存在重载吗？
第2学堂－专栏
07-19 9902
基类中的成员都可以被其派生类继承_C++基础知识 完结篇-继承-多态
weixin_34707242的博客
01-14 1660
整理码字不易，养成好习惯，点赞关注，你的支持就是我写下去的动力，谢谢老板。本文为C++第三篇后续接着这篇文章写，大家可以持续关注，前四篇在主页4.7 继承和派生4.7.1 继承概述4.7.1.1 为什么需要继承​网页类class IndexPage{public://网页头部void Header(){cout << "网页头部!" << endl;}//网页左侧菜单voi...
C++程序设计，主要为C++语言简介、面向对象的基本概念、类和对象进阶、运算符重载、类的继承与派生、多态与虚函数等章节总结
12-18
8. **继承与派生**：继承是类之间的一种关系，派生类可以从基类继承属性和行为。C++支持单继承和多继承。 9. **多态**：多态是指同一种行为在不同对象上有不同的表现形式。编译时多态通过函数重载实现，运行时多态...
南京邮电大学C++课件上课课件课件
03-20
在C++中，我们可以通过访问控制修饰符（如public、private和protected）来实现封装，限制对类内部成员的访问，保护数据的安全性。 接下来是继承，这是面向对象编程的另一个关键特性。继承允许我们创建一个新类...
C++进阶（语法篇）
10-19
继承是面向对象编程中又一重要概念，它允许创建一个新类（派生类）来继承另一个类（基类）的特性。多态和虚函数是实现继承后不同对象在运行时表现出不同行为的关键技术。多重继承则允许一个类同时继承多个基类，但也...
C++程序设计_面向对象进阶_C++_
09-30
3. **继承**：继承允许一个类（子类或派生类）从另一个类（父类或基类）继承属性和行为，减少了代码重复，增强了代码的可扩展性。C++支持单继承和多继承。 4. **多态性**：多态性使得不同类的对象可以对同一消息...
信管14：基类和派生类关系示例代码
明哥的专栏
05-07 848
/*  基类和派生类关系示例，    回答关联问题：  面向对象有哪几个基本特征？前面几章，我们讨论了其中哪几个特征？并解释。  掌握以下知识点：   1.掌握什么是多态？   2.多态分类：编译时多态和运行时多态。在C++中，二者是通过什么来实现的？  */ /*       本例讲基类与派生类对象间兼容关系                 */ #inclu
C++中派生类对基类成员的三种访问规则
weixin_43296982的博客
04-06 7867
C++中派生类对基类成员的访问形式有两种： 1.内部访问：派生类新增成员对从基类继承过来成员进行访问 2.对象访问：在派生类外部，通过派生类对象对从基类继承过来的成员进行访问 下面看看派生类对基类的成员的访问规则： 1.派生类私有继承了基类规则（private） 当类的继承方式是私有继承(private)时，基类中的public和protected成员被继承后称为派生类的私有成员，派生类的成员可以直接访问他们，但是在类的外部，通过派生类的对象是不可以对其进行访问的。还有基类中的私有成员在派生类中是不可以直接
公有继承基类和派生类之间构造和析构、赋值和拷贝构造函数的关系（下）
weixin_43973403的博客
03-09 261
公有继承基类和派生类之间构造和析构、赋值和拷贝构造函数的关系（下） 4、公有继承基类和派生类之间拷贝构造函数的关系 如果子类Text公有继承父类Object，在用已有的Text对象t1初始化Text对象t2时，如果没有写拷贝构造函数，系统的拷贝构造函数会把t1对象按位拷贝给t2对象，产生数据完全相同的t1和t2； 代码测试： #include<iostream> using namespace std; class Object { private: int val; public:
java类的派生_Java基类和派生类
weixin_34170737的博客
02-12 407
背景：对基类和派生类有更清晰的认识。从外部看来，派生类是一个与基类具有相同接口的新类，或许还会有一些额外的的方法和域 。但继承并不仅仅是类的复用。当创建了一个派生类的对象时，该类包含了一个基类的子对象。这个子对象和你用基类直接创建的对象没有什么两样。二者的区别在于，后者来自于外部，而基类的子对象来自于派生类对象的内部。对基类的子对象初始化时至关重要的，而且也只有一种方法来保证这一点，那就是在派生类...
C++使用技巧（三）：C++基类 & 派生类
源代码杀手的博客
10-25 2459
当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。 基类 & 派生类 一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下： class derived-class: access-specifier base-class 其中，访问修饰符 access-specifier 是 public、prote
JAVA基类和派生类
水墨江南
02-25 1370
  从外部看来，派生类是一个与基类具有相同接口的新类，或许还会有一些额外的的方法和域 。但继承并不仅仅是类的复用。当创建了一个派生类的对象时，该类包含了一个基类的子对象。这个子对象和你用基类直接创建的对象没有什么两样。二者的区别在于，后者来自于外部，而基类的子对象来自于派生类对象的内部。对基类的子对象初始化时至关重要的，而且也只有一种方法来保证这一点，那就是在派生类的构造器中调用基类的构造器，而...
5、继承与派生1-派生类的定义
weixin_30532759的博客
12-29 309
1、在c++中，派生类的一般定义语法为： class 派生类名：继承方式 基类名1，继承方式 基类名2，...，继承方式 基类名n { 　　派生类成员声明； }； 定义一个Dr1从基类Base1、Base2派生而来的新类： class Dr1：public Base1，private Base2 { 　　public: 　　　　Dr1(); 　　　　~Dr1(); }; 一...
c++的继承 《继承的概念及定义》《基类和派生类对象的赋值》《继承中的作用域》《派生类的默认成员函数》《继承与 友元》《基类与静态成员》
weixin_45726063的博客
07-10 202
继承的概念及定义 1.1 继承的概念： 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 ...
C++进阶：类继承与派生详解
不过，从C++11起，可以使用`using`语句来显式继承基类的构造函数，以便在派生类中调用它们。 派生类的构造和析构函数需要特别注意。派生类的构造函数需要调用基类的构造函数，以初始化基类的部分；而析构函数则按...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值