C++||继承

最新推荐文章于 2022-04-08 22:12:09 发布

半夏丶ExAg3r

最新推荐文章于 2022-04-08 22:12:09 发布

阅读量195

点赞数

分类专栏： C++学习

本文链接：https://blog.csdn.net/HuiDiExAg/article/details/110141317

版权

C++学习专栏收录该内容

7 篇文章 0 订阅

订阅专栏

继承

继承（inheritance）是面向对象程序设计使代码复用的手段。它允许程序员在保持原有类特性的基础上进行扩展**，从而产生新的类，称为派生类也叫作子类。继承是设计层次的复用。

1. 继承方式和访问限定符

1.1继承方式分为三种

1.public继承

2.protected继承

3.private继承

1.2访问限定符

1.public访问

2.protected访问

3.private访问

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

类成员/继承方式 public继承 protected继承 private继承
基类的public成员派生类的public成员派生类的protected成员派生类的private成员
基类的protected成员派生类的protected成员派生类的protected成员派生类的private成员
基类的private成员在派生类中不可见在派生类中不可见在派生类中不可见

总结：

基类的private成员在派生类中无论以什么方式继承都是不可见的。**不可见：**基类的私有成员依旧被继承到了派生类中，但是语法上限制了派生类对象不管在类外还是类内都不能去访问它
如果基类的成员不想在类外被访问，但需要在派生类中能访问，就定义为protected。保护限定符是因继承才出现的
对于上面表格进行总结。基类的私有成员在子类都是不可见的。基类的其他成员在子类的访问方式=Min（成员在基类的访问限定符，继承方式），public > protected > private
关键字class默认的继承方式是private，struct默认的继承方式是public
在实际应用中一般使用的都时public继承，几乎很少使用protected和private继承。因为protected和private继承下来的成员只能在派生类中使用，实际中扩展维护性不高。

类成员/继承方式	public继承	protected继承	private继承
基类的public成员	派生类的public成员	派生类的protected成员	派生类的private成员
基类的protected成员	派生类的protected成员	派生类的protected成员	派生类的private成员
基类的private成员	在派生类中不可见	在派生类中不可见	在派生类中不可见

3. 基类和派生类对象赋值转换

派生类的对象可以赋值给基类的对象，基类的指针，基类的引用。形象的说法是切片
基类对象不可以赋值给派生类对象
基类的指针可以通过强制转换赋值给派生类的指针。但是必须是基类的指针指向派生类的对象时才是安全的。

#include <iostream>
#include <string>
 
class Person
{
protected:
	int _num = 111;
	std::string _name = "yk";
};
 
class Student : public Person
{
public:
	void Show()
	{
		std::cout << "_num: " << _num << std::endl;
		std::cout << "_name: " << _name << std::endl;
	}
 
private:
	int _num = 999;
	std::string _name = "oodk";
};
 
int main()
{
	Student stu;
	stu.Show();//输出999 oodk表示基类的成员变量被隐藏了
	return 0;
}

4. 继承中的作用域

在继承体系中基类和派生类都有着自己的独立作用域
子类和父类有同名的成员的话，子类成员将屏蔽父类对于同名成员的直接访问，这种情况叫做隐藏，也叫作重定向。（在子类成员函数中，可以使用基类::基类成员显式访问）
实际中在继承体系中最好不要定义同名的成员

#include <iostream>
#include <string>
 
class Person
{
protected:
	int _num = 111;
	std::string _name = "yk";
};
 
class Student : public Person
{
public:
	void Show()
	{
		std::cout << "_num: " << _num << std::endl;
		std::cout << "_name: " << _name << std::endl;
	}
 
private:
	int _num = 999;
	std::string _name = "oodk";
};
 
int main()
{
	Student stu;
	stu.Show();//输出999 oodk表示基类的成员变量被隐藏了
	return 0;
}

理解重载和隐藏

#include <iostream>
#include <string>
 
class A
{
public:
	void Show()
	{
		std::cout << "In A!" << std::endl;
	}
};
 
class B : public A
{
public:
	void Show(int i)
	{
		std::cout << "In B!" << std::endl;
	}
};
 
int main()
{
	//A和B中的Show函数构成了隐藏，因为不在同一个作用域中所以不是重载
	B b;
	b.Show(3);
	b.A::Show();//调用父类中的Show函数必须要显式调用，因为被隐藏了
	return 0;
}

5. 派生类的默认成员函数

6个默认的成员函数

派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函（无参的构造函数），则必须在派生类的构造函数中初始化链表阶段显式调用（可以在初始化阶段的任何一个地方）
派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化
派生类的operator=必须要调用基类的operator=完成基类的复制
派生类的析构函数会在被调用完成之后自动调用基类的析构函数清理基类成员。因为这样才能保证派生类的对象先清理派生类成员在清理基类成员的顺序

基类行为：基类构造函数() 基类析构函数

派生类行为：派生类构造函数() 派生类析构函数

派生类行为：基类构造函数，派生类构造函数，派生类析构函数，基类析构函数

#include <iostream>
#include <string>
 
 
class Person
{
public:
	Person(std::string name)
		: _name(name)
	{
		std::cout << "In Person Construction!" << std::endl;
	}
 
	Person(const Person& p)
		: _name(p._name)
	{
		std::cout << "In Person Construction=!" << std::endl;
	}
 
	Person& operator=(const Person& p)
	{
		if (this != &p)
		{
			_name = p._name;
			std::cout << "In Person operator=!" << std::endl;
		}
 
		return *this;
	}
 
	~Person()
	{
		std::cout << "In Person Destruction!" << std::endl;
	}
 
private:
	std::string _name;
};
 
 
class Student : public Person
{
public:
	Student(std::string name)
		: Person(name)
		, _name(name)
	{
		std::cout << "In Student Construction!" << std::endl;
	}
 
	Student(const Student& p)
		: Person(p)
		, _name(p._name)
	{
		std::cout << "In Student Construction=!" << std::endl;
	}
 
	Student& operator=(const Student& p)
	{
		if (this != &p)
		{
			//必须先对基类的成员进行拷贝构造
			Person::operator=(p);
			_name = p._name;
			std::cout << "In Student operator=!" << std::endl;
		}
 
		return *this;
	}
 
	~Student()
	{
		std::cout << "In Student Destruction!" << std::endl;
	}
 
private:
	std::string _name;
};
 
int main()
{
	Student s1("jack");
	Student s2(s1);
	Student s3("rose");
	s1 = s3;
	return 0;
}

6. 继承与友元

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

class A
{
public:
	friend void Display(const A& a);
public:
	void Show()
	{
		std::cout << "In A!" << std::endl;
	}
 
private:
	int _num = 34;
};
 
 
class B : public A
{
public:
	void Show()
	{
		std::cout << "In B!" << std::endl;
	}
 
private:
	std::string _name = "yk";
};
 
void Display(const A& a)
{
	std::cout << "Freind function In A!" << "_num" << a._num << std::endl;
	//std::cout << "Freind function In A!" << "_num" << b._name << std::endl; 
}
 
int main()
{
	A a;
	Display(a);//输出Friend function In A!_num34 
	return 0;
}

7. 继承与静态成员

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

class A
{
public:
	friend void Display(const A& a);
public:
	void Show()
	{
		std::cout << "_count" << _count << std::endl;
	}
 
	A()
	{
		_count++;
	}
 
private:
	int _num = 34;
 
public:
	static int _count;
};
 
int A::_count = 0;
 
 
class B : public A
{
public:
	void Show()
	{
		std::cout << "In B!" << std::endl;
	}
 
private:
	std::string _name = "yk";
};
 
class C : public A
{
 
private:
	int _c = 0;
};
 
void Display(const A& a)
{
	std::cout << "Freind function In A!" << "_count" << a._count << std::endl;
	//std::cout << "Freind function In A!" << "_num" << b._name << std::endl; 
}
 
int main()
{
	B b1;
	B b2;
	B b3;
	Display(b3);//_count 3
 
	C c;
	c.Show();//_count 4
	return 0;
}

8. 复杂菱形继承和菱形虚拟继承

1.单继承：一个子类只有一个直接父类

2.多继承：一个子类有两个或者两个以上的直接父类

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

菱形继承有数据冗余和二义性问题

class Person
{
 
public:
	std::string _name;
};
 
class Student : public Person
{
 
protected:
	int _num;
};
 
class Teacher : public Person
{
 
protected:
	int _id;
};
 
class Assistant : public Student, public Teacher
{
 
protected:
	std::string _majorCourse;
};
 
int main()
{
	Assistant as;
	//as._name = "YK";//出现错误，因为数据二义性，必须显式调用
	as.Student::_name = "YK";
	as.Teacher::_name = "LW";
	return 0;
}

显示调用：必须写作用域

【解决方法】
虚拟继承
可以解决菱形继承的二义性和数据冗余的问题。在上面的继承关系中，在Student和Teacher继承Person使用虚拟继承，即可解决问题.
内部不仅有着类B类C还有这着一个类B和类C共有的类A，类B和类C内部都有一个指向类A的指针

如何实现不存在数据二义性问题：

但是对于属于类B和类C的类A可以看到它内部没有地址空间，所以其实他只是一个指针，也就是一个地址
而只有共有的类A才有这地址空间可以存放数据_a,所以对于类B和类C内部的类A的指针，指向的就是这个独立的类A。从而实现了数据一致性了
d对象将类A放到了组成的最下面，这个类A同时属于类B和类C，那么B和C如何去找到共有的A呢？
这里是通过B和C的两个指针，指向的一张表。这两个指针叫做虚基表指针，这两个表叫做虚基表。虚基表中存在着偏移量，通过偏移量可以找到下面的类A

class A
{
 
public:
	int _a;
};
 
class B : virtual public A
{
 
public:
	int _b;
};
 
class C : virtual public A
{
 
public:
	int _c;
};
 
class D : public B, public C
{
 
public:
	int _d;
};
 
int main()
{
	D d;
	d._a = 0;//可以赋值，没有二义性问题
	d.B::_a = 2;
	d.C::_a = 1;
	d._b = 2;
	d._c = 3;
	d._d = 4;
	return 0;;
}

9. 总结

很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有了菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题
多继承可以认为是C++的缺陷之一，很多后来的OO语言都没有多继承，如java
继承和组合
public继承是一种is-a的关系，也就是说每个派生类对象都是一个基类对象
组合是一种has-a的关系。假设B组合了A，每个B对象都有着一个A对象
优先使用对象组合，而不是类继承（高内聚，低耦合）
继承允许你根据基类类的实现来定义派生类的实现，这种通过生成派生类的复用称为白箱复用(white-box reuse)。术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见。继承一定程度破坏了基类的封装，基类的改变，对于派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。对象组合要求被组合的对象具有良好定义的接口。这种复用风格称为黑箱复用(black-box reuse)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于保持每一个类被封装，内聚性高。
实际中尽量使用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地，有些关系就适合用继承，另外实现多态，也必须要继承。类之间的关系可以使用继承，可以使用组合就用组合。

半夏丶ExAg3r

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C++||继承

继承继承（inheritance）是面向对象程序设计使代码复用的手段。它允许程序员在保持原有类特性的基础上进行扩展**，从而产生新的类，称为派生类也叫作子类。继承是设计层次的复用。1. 继承方式和访问限定符1.1继承方式分为三种1.public继承2.protected继承3.private继承1.2访问限定符1.public访问2.protected访问3.private访问2.继承基类成员访问方式的变化类成员/继承方式public继承protected继承priv
复制链接

扫一扫

专栏目录