C++中的派生类与基类继承关系详解

最新推荐文章于 2024-10-18 22:34:44 发布

不会编程的小司

最新推荐文章于 2024-10-18 22:34:44 发布

阅读量402

点赞数

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/m0_73623852/article/details/134367229

版权

在C++中，派生类和基类之间的继承关系是非常重要的，本文将详细介绍派生类模型对象、派生类构造函数、派生类向基类的隐式类型转换以及父类子类之间的拷贝与赋值。

一、派生类模型对象简介

派生类模型对象包含多个组成部分，即派生类对象包含基类部分和派生类自身定义的成员函数。这使得我们可以用基类指针new一个子类对象，因为派生类对象含有基类部分，编译器帮我们做了一个隐式的类型转换。

    Men mymen;//子类（派生类对象），包含多个组成部分（也就是多个子对象）
	（1）一个是含有派生类自己定义的成员函数，成员函数的子对象
	（2）一个是该派生类所继承的基类的子对象，这个子对象中包含的是基类中定义的成员变量、
	成员函数（派生类对象含有基类对应的组成部分）
	Human* phuman = new Men;//为什么基类指针可有new 派生类对象？
	因为派生类对象含有基类部分，所有我们可以把派生类对象当成基类指针用
	换句话说我们可以用基类指针new一个子类对象
	编译器帮我们做了一个隐式的类型转换。
	这种转换的好处就是有些需要基类引用的地方，可以用派生类对象的指针代替
	如果有些需要用基类指针的地方，也可以用派生类对象的指针来代替

二、派生类构造函数

派生类实际是使用基类构造函数来初始化它的基类部分，而派生类控制派生类部分成员的初始化。通过派生类的构造函数初始化列表，我们可以很方便地传递参数给基类构造函数。 你基类控制你基类部分的成员初始化，派生类控制派生类部分成员的初始化，各司其职

Men mymen;//即调用基类构造函数又调用派生类构造函数
	派生类实际是使用基类构造函数来初始化它的基类部分，
	你基类控制你基类部分的成员初始化，派生类控制派生类部分成员的初始化，各司其职

	如何传递参数给基类构造函数？
	  通过派生类的构造函数初始化列表；

	例如1：
//例1
class E {
public:
	E(int i): m_valueE(i){};//初始化列表
private:
	int m_valueE;
};
//不写public继承，默认私有继承，struct默认公有继承
class B : public E {
public:
	B(int i, int j, int k):E(i),m_valueB(k){};//通过子类的初始化列表给父类的构造函数传递参数
public:
	int m_valueB;
};

	B b(10, 20, 50);//先执行基类的构造函数，再执行派生类的构造函数。
	                先执行派生类的析构函数，再执行基类的析构函数。

三、既当父类又当子类

继承关系一直传递，构成了一种继承链；最终结果就是派生类会包含直接基类的成员和间接基类的成员。

    class gra {...};
	class fa : public gra {....};//gra是fa的直接基类
	class son:public fa {...};//gra是son的间接基类（爷爷类）
	继承关系一直传递，构成了一种继承链；最终结果就是派生类son会包含直接基类的成员和间接基类的成员

四、不想当基类的类

final：加在类名后面，有这个关键字的类就不能做基类了
使用final关键字可以防止类被当作其他类的基类，如果类E不想当类B的基类，可以使用final关键字

class E final {
public:
    E(int i) : m_valueE(i) {};//初始化列表
private:
    int m_valueE;
};

// 不写public继承，默认私有继承，struct默认公有继承
class B : public E {
public:
    B(int i, int j, int k) :E(i), m_valueB(k) {};//通过子类的初始化列表给父类的构造函数传递参数
public:
    int m_valueB;
};

五、静态类型与动态类型

在C++中，静态类型指的是变量声明时的类型，而动态类型指的是指针或引用所指向的内存中的对象的类型。当基类指针或引用指向派生类对象时，静态类型和动态类型可能不一致。

Human* phuman = new Men;//基类指针指向一个派生类对象
Human& q = *phuman;//基类引用绑定到派生类对象上

静态类型：变量声明时候的类型。编译的时候是已知的。
动态类型：指的是指针或者引用所表达（代表）的内存中的对象的类型。这里是Men动态类型。
    动态类型  是在运行的时候才能知道。
动态类型，静态类型这种概念，只有基类指针/引用，才存在静态类型和动态类型不一致的情况。
如果不是基类的指针或者引用，那么静态类型和动态类型都应该是一致的。

六、派生类向基类的隐式类型转换

编译器会隐式地执行派生类到基类的类型转换，因为每个派生类对象都包含一个基类对象部分，使得基类的引用或指针可以绑定到基类对象部分。然而，从基类到派生类的自动类型转换是不合法的，但可以通过dynamic_cast进行转换。

    Human * phuman = new Men;//基类指针指向一个派生类对象
	Human& q = *phuman;//基类引用绑定到派生类对象上
	编译器隐式的帮我们执行了派生类到基类的转换。
	转换成功的原因：是因为每个派生类对象都包含一个基类对象部分，所有基类的引用或指针可以绑到基类对象部分。
	基类对象 能独立存在，也能作为派生类对象的一部分存在。
	并不存在从基类到派生类的自动类型转换。如：Men *pen=new Human;
	Human human;
	Men& my = human;//非法，不能将基类转换成派生类。（派生类的引用不能绑定到基类的对象上去）
	Men* pmen = &human;//非法，不能将基类转换成派生类（派生类指针不能指向基类地址）

	Men men;
	Human* phuman = &men;//可以
	Men* pmen = phuman;//不可以，编译器，通过静态类型推断判断转换合法性。发现基类不能转成派生类
	如果基类中有虚函数的话，可以通过dynamic_cast可以转换。
	Men* pmen = dynamic_cast<Men*>(phuman);
	if (pmen != nullptr) {
		  ....
	}

七、父类子类之间的拷贝与赋值

用派生类对象为一个基类对象初始化或者赋值时，只有该派生类对象的基类部分会被拷贝或者赋值，而派生类部分将被忽略。

例3
	Human(const Human& tephuman)//tephuman是得到了Men对象的引用。但是，Human作为基类，
		                        //只能处理自己的成员即便是一个派生类对象
	{
		int a;
		a = 1;
	}
	//例4
	Human& operator=(const Human& tmphuman)
	{
		//...
		return *this;
	}
	//例3
	Human human(men);//用派生类对象来定义并初始化基类对象。这个会导致拷贝构造函数的执行。
	Men men;
	Human human;
	//例4
	human = men;//调用的是赋值运算符

class Human {
public:
    virtual void speak() {
        cout << "I am a human" << endl;
    }
};

class Men : public Human {
public:
    void speak() override {
        cout << "I am a man" << endl;
    }
};

int main() {
    Human* phuman = new Men;
    Human& q = *phuman;

    Men men;
    Human* phuman2 = &men;
    Men* pmen = dynamic_cast<Men*>(phuman2);
    if (pmen != nullptr) {
        pmen->speak();
    }

    Men men1;
    Human human(men1);

    Men men2;
    Human human2;
    human2 = men2;

    return 0;
}