C++继承和多态

class Person
{
public:
	Person(string name,int age,string gender)
		:_name(name),_age(age),_gender(gender)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)
	{
		cout << "Person(const Person& p)" << endl;
	}
	Person& operator=(const Person& p)
	{
		cout << "Person.operator=()" << endl;
		return *this;
	}
	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name;//姓名
	int _age;//年龄
	string _gender;//性别
};
class Student:public Person
{
private:
	string _id;//学号
	string _college;//所属学院
public:
	Student(string name, int age, string gender,string id,string college)
		:Person(name,age,gender)//调用父类构造
		,_id(id),_college(college)
	{
		//初始化子类成员
		cout << "Student()" << endl;
	}
	Student(const Student& s)
		:Person(s)//调用父类拷贝构造
	{
		//拷贝子类成员
		cout << "Student(const Student& s)" << endl;
	}
	Student& operator=(const Student& s)
	{
		Person::operator=(s);//调用父类的operator=
		cout << "Student.operator=()" << endl;
		//赋值子类成员
		return *this;
	}
	~Student()
	{
		//默认自动先调用子类析构，再调用父类析构
		cout << "~Student()" << endl;
	}
};
int main()
{
	Student s("cx", 20, "男", "2022112102601", "计算机与信息工程学院");//构造
	Student s2 = s;//拷贝构造
	Student s3("xxx", 18, "女", "2022112102728", "经济管理学院");//构造
	s3 = s2;//赋值
	return 0;
}

代码输出结果：

多继承

多继承：多继承就是一个类可以继承多个父类。

多继承会导致的问题：菱形继承，图示如下

为什么说菱形继承会有问题？

由于继承的本质是代码的复用，而菱形继承会导致A类对象在D类对象中存在两份，导致数据冗余和二义性。

如何解决：虚继承

虚继承就是多个类在继承重复类时，都使用虚继承。这样在上图中D对象内就只会有一份A对象，消除了对象的冗余。

继承is a和组合has a

继承和组合本质都是代码的复用，使得一个对象存在于另一个对象之中。

继承：
class B
{
protected:
	int _b;
};
class A :public B
{
//A中可以直接使用父类的protected和public成员
protected:
	int _a;
};
组合：
class B
{
protected:
	int _b;
};
class A
{
protected:
	B _b;//B类对象作为成员,只能使用B类对象的public成员
	int _a;
};
由于组合只能使用另一个对象的公有成员，这使得组合而成的类之间耦合度更低，因此在组合和继承都可以达到目的时，组合方案更优。

多态

什么是多态

多态：多态就是一个接口多种实现，多种状态，是面向对象编程语言的一重要特征。当使用父类指针或引用接收子类对象指针或引用，并调用子类对象中重写的虚函数时，就会体现出多态性。即指向父类调父类，指向子类调子类。
class Animal //基类
{
public:
	virtual void say()//虚函数
	{
		cout << "animal say " << endl;
	}
};
class Cat:public Animal  //子类，重写基类的虚函数
{
public:
	virtual void say()
	{
		cout << "cat say miao~miao~" << endl;
	}
};
class Dog :public Animal  //子类，重写基类的虚函数
{
public:
	virtual void say()
	{
		cout << "dog say wang~wang~" << endl;
	}
};
void func(Animal* n)//基类指针/引用接收
{
	n->say();//多态调用
}
int main()
{
	Animal a;
	Cat c ;
	Dog d;
	func(&a);
	func(&c);
	func(&d);
	return 0;
}
上面的代码基类为Animal，子类有Cat和Dog，当使用基类指针或引用接收对象的指针或引用时，指向哪个类调用哪个类的虚函数。

形成多态的条件

1.具有继承关系

2.虚函数重写

3.父类指针或引用调用虚函数

函数重载，隐藏，重写的区别

重载：同一作用域内，函数名相同，参数不同。

隐藏（重定义）：子类函数和父类函数名字相同。父类函数就被隐藏了。

重写（覆盖）：子类函数和父类函数名字相同，参数相同，返回类型相同，且父类函数是虚函数。

override和final

子类重写父类虚函数时，用override修饰子类重写的函数，用于检查是否成功重写（三同或者协变）。如果不构成重写在编译时就会报错。

用final修饰的类，不允许有子类继承

用final修饰的虚成员函数，在子类中不可被重写

多态原理

首先看一下这段代码

class A
{
public:
	void func()
	{
		;
	}
};
int main()
{
    A a;
	cout << sizeof(a) << endl;
	return 0;
}

因为类的成员函数存放在代码段，并不会在每个对象中单独存放一份，所以这里是空类，但是打印的是1，是因为要用至少一个字节来标识不同的对象。

class A
{
public:
	virtual void func()
	{
		;
	}
};
int main()
{
	A a;
	cout << sizeof(a) << endl;
	return 0;
}

这个类的大小是多少呢？

这又是为什么呢？为什么函数由普通函数变为虚函数，对象的大小就变了呢？

这是因为类中的每个虚函数地址要放到一个专门的位置，即虚函数表中。

对象中会多存放一个虚函数表指针，虚函数表中存放着一个类中所有的虚函数指针。

指针的大小在32位计算机上为4字节，64位计算机为8字节，所以类的大小变为8字节。

这和多态有什么关系呢？

子类继承父类时，会把父类对象中的虚函数表也继承下来。

重写虚函数前：

子类虚函数表中的虚函数地址和父类虚函数表中的虚函数地址是相同的。

重写之后：子类虚函数表中的虚函数地址会被重写的虚函数地址"覆盖"。

虚函数指针被覆盖后，此后在多态的条件下，基类指针指向父类对象时，编译器会在父类对象的虚函数表中查找虚函数，指向子类对象时，编译器会在子类对象的虚函数表中查找虚函数。进而体现出了指向谁，调用谁的多态性。

原文地址:https://blog.csdn.net/2301_76144863/article/details/140164613 本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：https://www.suanlizi.com/kf/1812430346122301440.html 如若内容造成侵权/违法违规/事实不符，请联系《酸梨子》网邮箱：1419361763@qq.com进行投诉反馈，一经查实，立即删除！

阅读全部