C++基类指针或引用指向或引用派生类对象（实现动态多态四种手段）父类指针访问子类成员变量（需要dynamic_cast）

时间：2025-03-14 17:22:01

文章目录

    • 背景
    • 多态示例：父类指针指向子类对象
    • 父类指针指向子类对象，如何通过父类指针访问到子类特定的成员变量
    • 实现动态多态的四种手段：基类的指针或引用指向或引用一个派生类对象（new或不new）

背景

比如有父类Animal和子类Cat，用new创建对象有以下四种方式：

Animal* p = new Cat();
Animal* pp = new Animal();
Cat* q = new Cat();
Cat* qq = new Animal();

其中第四种是不合法的。

第二种和第三种都好理解，但是第一种，用父类指针指向了子类对象，这种是干嘛用的的????

这是用来实现多态的

多态示例：父类指针指向子类对象

使用父类指针指向子类对象时，可以实现多态性，即在运行时根据对象的实际类型来调用相应的函数。这样可以方便地实现代码的扩展和维护，同时也可以提高代码的可读性和可维护性。

下面是一个简单的示例代码，演示了使用父类指针指向子类对象的好处：

#include <iostream>
using namespace std;

class Animal
{
public:
	virtual void speak()
	{
		cout << "Animal speaks" << endl;
	}
	string name;
};

class Cat : public Animal
{
public:
	void speak()
	{
		cout << "Cat speaks" << endl;
	}

	string name;
};

class Dog : public Animal
{
public:
	void speak()
	{
		cout << "Dog speaks" << endl;
	}
};

int main()
{
	Animal *p1 = new Cat();
	Animal *p2 = new Dog();
	p1->speak(); // 输出 Cat speaks
	p2->speak(); // 输出 Dog speaks
	delete p1;
	delete p2;
	return 0;
}

在上面的代码中，Animal是一个基类，Cat和Dog是Animal的子类。在main函数中，我们使用Animal指针p1和p2分别指向Cat对象和Dog对象。由于speak函数是虚函数，因此在运行时会根据对象的实际类型来调用相应的函数。因此，p1->speak()会调用Cat类中的speak函数，输出"Cat speaks"，p2->speak()会调用Dog类中的speak函数，输出"Dog speaks"。

如果我们不使用父类指针指向子类对象，而是直接使用Cat和Dog对象，那么我们就需要分别调用它们的speak函数，这样会导致代码的重复和冗余，不利于代码的扩展和维护。

父类指针指向子类对象，如何通过父类指针访问到子类特定的成员变量

当使用父类指针指向子类对象时，无法直接访问子类中特定的成员变量。但是，可以通过将父类指针转换为子类指针或引用来访问子类中特定的成员变量。

在C++中，可以使用dynamic_cast运算符将父类指针或引用转换为子类指针或引用，从而访问子类中特定的成员变量。需要注意的是，dynamic_cast运算符只能用于含有虚函数的类类型之间的转换，而且转换时会进行类型检查，如果转换失败会返回空指针或引用。

下面是一个简单的示例代码，演示了如何使用dynamic_cast运算符访问子类中特定的成员变量：

#include <iostream>
using namespace std;

class Animal
{
public:
	virtual void speak()
	{
		cout << "Animal speaks" << endl;
	}
};

class Cat : public Animal
{
public:
	string name;
	void speak()
	{
		cout << "Cat speaks" << endl;
	}
};

int main()
{
	Animal *p = new Cat();
	p->speak(); // 输出 Cat speaks
	Cat *q = dynamic_cast<Cat *>(p);
	if (q != nullptr)
	{
		q->name = "Tom";
		cout << q->name << endl; // 输出 Tom
	}
	delete p;
	return 0;
}

在上面的代码中，Animal类中没有定义name成员变量，而Cat类中定义了name成员变量。在main函数中，我们使用Animal指针p指向Cat对象，然后使用dynamic_cast运算符将p转换为Cat指针q，从而访问Cat类中的name成员变量。需要注意的是，在转换时需要进行类型检查，如果转换失败会返回空指针。

参考文章：C++四种cast转换（const_cast、static_cast、dynamic_cast、reinpreter_cast）类型转换运算符

实现动态多态的四种手段：基类的指针或引用指向或引用一个派生类对象（new或不new）

可以定义一个基类的指针或引用，然后将其指向或引用一个派生类的对象。这样，通过基类的指针或引用调用虚函数时，会根据实际指向的对象类型来动态调用相应的函数，从而实现多态。

下面是一个使用指针实现多态的示例代码：

#include <iostream>
using namespace std;

// 重写示例
class Base
{
public:
	virtual void func()
	{
		cout << "Base::func()" << endl;
	}
};

class Derived : public Base
{
public:
	virtual void func()
	{
		cout << "Derived::func()" << endl;
	}
};

int main()
{

	// 方法1：new，父类指针指向子类对象
	Base *p = new Derived();
	p->func(); // 输出 Derived::func()
	delete p;

	cout << "----" << endl;
	// 或者

	// 方法2：不new，父类指针指向子类对象
	Derived dd;
	Base *pp = &dd;
	pp->func(); // 输出 Derived::func()

	cout << "----" << endl;
	// 或者

	// 方法3：不new，父类引用引用子类对象
	Derived ddd;
	Base &ppp = ddd;
	ppp.func(); // 输出 Derived::func()

	cout << "----" << endl;
	// 或者

	// 方法4：new，父类引用引用子类对象
	Base &pppp = *(new Derived());
	pppp.func(); // 输出 Derived::func()
	delete &pppp;

	return 0;
}

在上面的代码中，定义了一个基类的指针或引用，然后将其指向一个派生类对象。通过基类的指针或引用调用虚函数时，会根据实际指向的对象类型来动态调用相应的函数，从而输出派生类中的func()函数的内容。

相关文章