老生常谈C++ 中的继承

继承

1 什么是继承

1.1 继承的概念

继承机制是面向对象程序设计使代码可以复用的最重要的手段,这个机制允许程序员在保持原有类特性的基础上进行扩展,增加功能,这样产生新的类,称为派生类。继承呈现了面向对象程序设计的层次结构,体现了由简单到复杂的认知过程。以前解除的都是函数复用,继承是类设计层次的复用

代码演示如下

#include <iostream>
#include <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;
};
int main()
{
	Person p;
	Student s;
	p.Print();
	s.Print();
	return 0;
}

继承后父类的Person的成员(成员函数+成员变量)都会变成子类的一部分。这里体现出了Student复用了Person的成员。下面我们使用监视窗口查看Student对象,可以看到变量的复用。调用Print可以看到成员函数的复用。

成员变量的复用

成员函数的复用

1.2 继承的定义

1.2.1 定义格式

Person是父类,也称作基类。Student是子类,也称作派生类。

1.2.2 继承关系和访问限定符

1.2.3 继承基类成员访问方式的变化

注意(重点)

  • 基类 private 成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中,但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
  • 基类 private 成员在派生类中是不能被访问,如果基类成员不想在类外直接被访问,但需要在派生类中能访问,就定义为protected。可以看出保护成员限定符是因继承才出现的。
  • 实际上面的表格我们进行一下总结会发现:基类的私有成员在子类都是不可见的。基类的其他成员在子类的访问方式 = Min(成员在基类的访问限定符,继承方式),public > protected > private。
  • 使用关键字class时默认的继承方式是private,使用struct时默认的继承方式是public,不过最好显示的写出继承方式。
  • 在实际运用中一般使用都是public继承,几乎很少使用protetced/private继承,也不提倡使用protetced/private继承,因为protetced/private 继承下来的成员都只能在派生类的类里面使用,实际中扩展维护性不强。

2 基类(父类)对象和派生类(子类)对象之间的赋值转换

  • is a 的关系:一个子类是一个父类,比如,一个学生是一个人
  • 派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去(重点掌握),代码演示如下。
#include <iostream>
#include <string>
using namespace std;

class Person
{
public:
	    // 缺省
		string _name = "陈志浩"; // 姓名
		string _sex = "男"; // 性别
		int _age = 25; // 年龄
};
class Student : public Person
{
public:
	int _No = 2019124084; // 学号
};

void Test()
{
	Person pobj;
	Student sobj;
	// 修改子类的成员变量方便演示
	sobj._name = "chenzhiiao";
	sobj._age = 23;
}
int main()
{
	Test();
	return 0;
}


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

指向基类的指针可以指向子类,并且可以强制转换为子类指针,引用同理也是可以的,这里有点诡异,其实也可以这样理解:这里指针指向的地址是一样的,只不过类型限制了可以看哪些部分,所以再强制转换回子类指针才不会出错。


上面这些类型转换都必须是在公有继承的前提下的。

3 继承中的作用域

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

来上代码

#include <iostream>
using namespace std;

class A {
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class B : public A {
public:
	void fun(int i)
	{
		cout << "func(int i)->" << i << endl;
	}
};
void Test()
{
	// B中的fun和A中的fun不是构成重载,因为不是在同一作用域
	// B中的fun和A中的fun构成隐藏,成员函数满足函数名相同就构成隐藏。
	B b;
	b.fun(10);
	b.A::fun();//可以使用 基类::基类成员 显示访问
};
int main()
{
	Test();
	return 0;
}

4 派生类(子类)的默认成员函数

派生类的6个默认成员函数,默认就是我们不写但是会自己生成,那么这4(只关注 构造、拷贝构造、析构、赋值重载)个默认成员函数是如何生成的呢?

派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数,则必须在派生类构造函数的初始化列表阶段显示调用,派生类对象初始化先调用基类构造再调派生类构造。

#include <iostream>
#include <string>
#include <ostream>
using namespace std;
class Person
{
public:
	friend ostream& operator<<(ostream& out, const Person& p);
	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; // 姓名
};
ostream& operator<<(ostream& out, const Person& p)
{
	out << "name : " << p._name << endl;
	return out;
}
class Student : public Person{
public:
	friend ostream& operator<<(ostream& out, const Student& s);
	Student(const char* name = "chenzhiao", int no = 2019)
		:Person(name)
		,_no(no)
	{
		cout << "Student()" << endl;
	}

	~Student()
	{
		cout << "~Student()" << endl;
	}

protected:
	int _no;
};
ostream& operator<<(ostream& out, const Student& s)
{
	out << "name : " << s._name << ",no : " << s._no << endl;
	return out;
}

void Test()
{
	Student s1;
	cout << s1;
};
int main()
{
	Test();
	return 0;
}

派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化,下面代码中的 Person(s) 有切片行为。

Student(const Student& s)
		: Person(s), _no(s._no)
	{
		cout << "Student(const Student& s)" << endl;
	}

派生类的operator=必须要调用基类的operator=完成基类的复制。

Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);
			//这里必须要用类名指定,否则子类的operator=会把父类的
			//的operator=隐藏掉,导致无限递归调用子类的operator=导致栈溢出
			_no = s._no;
		}
		return *this;
	}

派生类对象析构清理先调用派生类析构再调基类的析构,这里 c++ 的编译器就保证了先调用子类的析构再调用父类的析构。
有两个迷惑点:1、子类的析构函数和父类的析构函数构成 隐藏,这是因为多态重写的需要(下一篇文章我会拉出来再谈一下),所有类的析构函数,名字会被统一处理成 destructor 2 、 如果自己显示调用,存在父类会析构的问题,不符合先定义后析构的规则

~Student()
	{
		cout << "~Student()" << endl;
		Person::~Person();
		//C++的编译器保证了这个代码默认会执行,但是必须要放在最后一行才符合规则
		//不能让程序员去手动指定Person::~Person();必须要放在最后一行
		//万一程序员不小心放在了第一行,会导致一些不可预料的错误,所以不要显示调用
		//这和上面3个默认成员的规则不一样,需要多注意
	}

最后补上一张图,有助于理解

5 继承与友元

友元关系不能继承,也即是说:基类友元不能访问子类私有和保护成员

6 继承与静态成员

基类定义了 static 静态成员,则整个继承体系里面只有一个这样的成员,无论派生出多少个子类,都只有一个 static 成员实例

来段代码

#include <iostream>
#include <string>
using namespace std;

class Person
{
public:
	Person() { ++_count; }
protected:
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};
int Person::_count = 0;
class Student : public Person
{
protected:
	int _stuNum; // 学号
};
class Graduate : public Student
{
protected:
	string _seminarCourse; // 研究科目
};
void TestPerson()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	Person s5;
	cout << " 人数 :" << Person::_count << endl;
	Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl;
}
int main()
{
	TestPerson();
	return 0;
}

7 复杂的菱形继承以及菱形虚拟继承

7.1 单继承

一个子类只有一个直接父类,这种继承关系叫做单继承

7.2 多继承

一个子类有两个或者两个以上的父类叫做多继承

7.3 菱形继承

菱形继承是多继承的一种特殊情况


7.3.1 菱形继承的问题

菱形继承存在很大的问题,从上面的对象模型图里可以得出:菱形继承有数据冗余和数据二义性的问题,在Assistant 的对象里 Person 成员有两份

#include <iostream>
#include <string>
using namespace std;

class Person{
public:
	string _name;
};
class Student : public Person{
protected:
	int _stuId;
};
class Teacher : public Person{
protected:
	int _teaId;
};
class Assistant : public Student, public Teacher{
protected:
	string _majorCourse;
};
void Test()
{

	Assistant a;
	//a._name = "chenzhiao"; 这样会有二义性无法明确知道访问的是哪一个

	// 需要显式指定访问哪个父类的成员可以解决二义性的问题,但是数据冗余的问题还是无法解决

	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";

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

7.3.2 如何解决

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系,在Student和Teacher的继承,Person时使用虚拟继承,即可解决问题。需要注意的是,虚拟继承不要在其他地方去使用,改进上面的代码。

#include <iostream>
#include <string>
using namespace std;

class Person{
public:
	string _name;
};
class Student : virtual public Person{
protected:
	int _stuId;
};
class Teacher : virtual public Person{
protected:
	int _teaId;
};
class Assistant : public Student, public Teacher{
protected:
	string _majorCourse;
};
void Test()
{

	Assistant a;
	a._name = "chenzhiao";

}
int main()
{
	Test();
	return 0;
}
// 在菱形继承的“肩膀处”添加完 virtual 关键字,完成虚拟继承,可以解决数据的二义性和冗余问题。我们来看一下监视窗口

7.3.3 虚拟继承解决数据冗余和二义性的原理

为了研究虚拟继承原理,我们给出了一个简化的菱形继承体系,再借助内存窗口观察对象成员的模型。

#include <iostream>
#include <string>
using namespace std;

class A {
public:
	int _a;
};
// class B : public A
class B : public A {
public:
	int _b;
};
// class C : public A
class C : public A {
public:
	int _c;
};
class D : public B, public C {
public:
	int _d;
};

void Test()
{
	D d;
	cout << sizeof(d) << "字节" << endl;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;

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

下图是菱形继承的内存对象成员模型:这里可以看到数据冗余

下图是菱形虚拟继承的内存对象成员模型

  • 可以分析出 D对象中将 A 放在了对象组成的最下面,这个 A 同时属于 B 和 C,那么 B 和 C 如何找到公共的 A 呢?这里是通过了 B 和 C 的虚基表指针,这两个指针指向了虚基表,**虚基表存的是当前位置距离 虚基类对象(A)的偏移量,通过偏移量找到A。尤其是发生切片行为的时候,比如 B& b = d,这个偏移量会帮助 b 找到自己的a,完成切片行为。注意:菱形虚拟继承的效率并不高,因为这一顿操作可想而知,所以尽量不要定义菱形虚拟继承,这也是 C++ 语法设计的几个大 bug。
  • **下面是上面的Person关系菱形虚拟继承的原理解释:

8 继承的扩展和总结

  • 多继承就是C++语法复杂的体现,有了多继承就有了菱形继承,有了菱形继承就有了菱形虚拟继承,底层实现就很复杂,所以不建议设计多进程,更不要设计出菱形继承。否则在复杂度及性能上都有问题。
  • 可以认为多继承就是 C++ 的缺陷之一,很多后来的OO语言都没有多继承,如Java。

8.1 继承和组合

  • public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象,比如 狗是一种动物
  • 组合是一种has-a的关系。假设B组合了A,每个B对象中都有一个A对象。
  • 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用,(white-box reuse)。术语“白箱”是相对可视性而言:在继承方式中,基类的内部细节对子类可见 。继承一定程度破坏了基类的封装,基类的改变,对派生类有很大的影响。派生类和基类间的依赖关系很强,耦合度高。
  • 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse),因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。 组合类之间没有很强的依赖关系,耦合度低。优先使用对象组合有助于你保持每个类被封装。
  • 实际尽量多去用组合。组合的耦合度低,代码维护性好。不过继承也有用武之地的,有些关系就适合继承那就用继承,另外要实现多态,也必须要继承。类之间的关系可以用继承,可以用组合,就用组合。

到此这篇关于老生常谈C++ 中的继承的文章就介绍到这了,更多相关C++继承内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • C++类中的继承实例详解

    C++类中的继承实例详解 实例效果: 实现代码: #include<iostream> #include<string> using namespace std; class Person { public: Person(const char* name = "abc") :_name(name) { cout << "Person()" << endl; } Person(const Person& pp)

  • 详解C++中实现继承string类的MyString类的步骤

    昨天师兄又出了道测试题,让我们实现类似于string类的没有MyString类,刚开始很头疼,可是真正在自己写代码的时候又很兴奋的发现,这个过程真的是个很宝贵的机会,让我又有机会可以很好的熟悉回顾C++的很多知识-类设计,构造析构函数,成员函数,友元函数,引用,重载,字符串操作,动态内存分布.....于是昨天花了半天时间写了300多行代码,并认真的进行了相关测试.修改和总结.因为内容有点丰富,所以想分几次写出来,条理也清楚些. 类的空间分配:类给它的每个对象都分配了独立的空间去存储它的数据成员,

  • C++ 类的继承与派生实例详解

     C++ 类的继承与派生实例详解 继承性是面向对象程序设计最重要的特性之一,使软件有了可重用性,C++提供的类的继承机制. 继承与派生的概念 一个新类从已有的类那里获得已有的特性,这种现象称为类的继承.同样也可以说成已有的类派生出来了新的类.类A继承自类B也就是类B派生了类A.所以继承和派生的关系就像小学时把字句和被字句的造句一样.有了继承与派生后,就有了父类/基类与子类/派生类,C++中将类B称为父类/基类,将类A称为子类/派生类. 派生类的声明: #include <iostream> u

  • C++ 继承详解及实例代码

    C++继承可以是单一继承或多重继承,每一个继承连接可以是public,protected,private也可以是virtual或non-virtual.然后是各个成员函数选项可以是virtual或non-virtual或pure virtual.本文仅仅作出一些关键点的验证. public继承,例如下: 1 class base 2 {...} 3 class derived:public base 4 {...} 如果这样写,编译器会理解成类型为derived的对象同时也是类型为base的对象

  • C/C++ 公有继承、保护继承和私有继承的对比详解

    C/C++ 公有继承.保护继承和私有继承的区别 在c++的继承控制中,有三种不同的控制权限,分别是public.protected和private.定义派生类时,若不显示加上这三个关键字,就会使用默认的方式,用struct定义的类是默认public继承,class定义的类是默认private继承.这和Java有很大的不同,Java默认使用public继承,而且只有公有继承. 1.使用public继承时,派生类内部可以访问基类中public和protected成员,但是类外只能通过派生类的对象访问

  • 老生常谈 Java中的继承(必看)

    Java作为一面向对象的语言,具备面向对象的三大特征--继承,多态,封装. 继承顾名思义,继任,承接,传承的意思.面向对象的语言有一个好处,就是可以用生活中的例子来说明面向对象的特性.那么我们先来看看生活中的继承关系有哪些?最常见的:父母子女:汽车,电动车,自行车和车.无论哪种车,都有具备车的特性.再比如说:家里面的电饭锅,电磁炉,电冰箱.他们都属于电器类,都具有名字这个属性,也都需要用电这个方法.如果在程序中我们一个个类去把这些重复的代码都写上去,那不是浪费时间和精力吗?联系之前的知识,我们能

  • 老生常谈C++ 中的继承

    继承 1 什么是继承 1.1 继承的概念 继承机制是面向对象程序设计使代码可以复用的最重要的手段,这个机制允许程序员在保持原有类特性的基础上进行扩展,增加功能,这样产生新的类,称为派生类.继承呈现了面向对象程序设计的层次结构,体现了由简单到复杂的认知过程.以前解除的都是函数复用,继承是类设计层次的复用. 代码演示如下 #include <iostream> #include <string> using namespace std; class Person { public: v

  • 老生常谈JS中的继承及实现代码

    JS虽然不像是JAVA那种强类型的语言,但也有着与JAVA类型的继承属性,那么JS中的继承是如何实现的呢? 一.构造函数继承 在构造函数中,同样属于两个新创建的函数,也是不相等的 function Fn(name){ this.name = name; this.show = function(){ alert(this.name); } } var obj1 = new Fn("AAA"); var obj2 = new Fn("BBB"); console.lo

  • 老生常谈Javascript中的原型和this指针

    1.Javascript中的原型: 原型prototype是Javascript中特有的一个概念.通过原型,Javascript可以实现继承机制. Javascript本身是基于原型的,每一个对象都有一个prototype属性.而Object对象的prototype属性为null. 下面来看一个使用原型实现继承的例子: 1.1使用原型实现继承: function Person(name){ this.name = name; this.getName = function(){ return t

  • 老生常谈ES6中的类

    前面的话 大多数面向对象的编程语言都支持类和类继承的特性,而JS却不支持这些特性,只能通过其他方法定义并关联多个相似的对象,这种状态一直延续到了ES5.由于类似的库层出不穷,最终还是在ECMAScript 6中引入了类的特性.本文将详细介绍ES6中的类 ES5近似结构 在ES5中没有类的概念,最相近的思路是创建一个自定义类型:首先创建一个构造函数,然后定义另一个方法并赋值给构造函数的原型 function PersonType(name) { this.name = name; } Person

  • C++ 中私有继承的作用

    C++ 中私有继承的作用 私有继承的 第一个规则:和公有继承相反,如果两个类之间的继承关系为私有,编译器一般不会将派生类对象转换成基类对象. 第二个规则: 从私有基类继承而来的成员都成为了派生类的私有成员,即使它们在基类中是保护或公有成员. 私有继承的含义:私有继承意味着 "用...来实现". 如果使类D私有继承于类B,这样做是因为你想利用类B中已经存在的某些代码,而不是因为类型B的对象和类型D的对象之间有什么概念上的关系. 因而,私有继承纯粹是一种实现技术. 私有继承意味着只是继承实

  • 老生常谈计算机中的编码问题(必看篇)

    计算机中的编码问题 因为计算机只能处理数字,如果要处理文本,就必须先把文本转换为数字才能处理.最早的计算机在设计时采用8个比特(bit)作为一个字节(byte),所以,一个字节能表示的最大的整数就是255(二进制11111111=十进制255),如果要表示更大的整数,就必须用更多的字节.比如两个字节可以表示的最大整数是65535,4个字节可以表示的最大整数是4294967295. 一.目前常用的编码 ASCII编码:由于计算机是美国人发明的,因此,最早只有127个字母被编码到计算机里,也就是大小

  • 老生常谈angularjs中的$state.go

    路由是这么定义的: $stateProvider .state('page1', { url: '/page1', templateUrl: 'views/page1.htm', controller: 'page1Ctrl' }) .state('page2', { url: '/page2/:type', templateUrl: 'views/page2.htm', controller: 'page2Ctrl' }); 用ng-href跳转的话,是这么写的: ng-href="#/pag

  • java中子类继承父类,程序运行顺序的深入分析

    我们经常在项目中使用继承,但是往往不太明白,程序运行的顺序以及原理,尤其是使用上转型对象的时候,以及父类子类中都有static变量和方法时,不知道先运行谁.我也是写了一个例子.总结了一下. 复制代码 代码如下: 父类:public class TestStatic { public static String name="china"; {       System.out.println("========方法体========");    } static{  

  • 老生常谈java中的Future模式

    jdk1.7.0_79 本文实际上是对上文<简单谈谈ThreadPoolExecutor线程池之submit方法>的一个延续或者一个补充.在上文中提到的submit方法里出现了FutureTask,这不得不停止脚步将方向转向Java的Future模式. Future是并发编程中的一种设计模式,对于多线程来说,线程A需要等待线程B的结果,它没必要一直等待B,可以先拿到一个未来的Future,等B有了结果后再取真实的结果. ExecutorService executor = Executors.

随机推荐