【C++的探索路16】多态与虚函数之练习篇

最新推荐文章于 2023-07-04 12:42:00 发布

Guerrouj

最新推荐文章于 2023-07-04 12:42:00 发布

阅读量556

点赞数

分类专栏：我的C/C++入门

本文链接：https://blog.csdn.net/u010369450/article/details/78964906

版权

我的C/C++入门专栏收录该内容

30 篇文章 2 订阅

订阅专栏

写出下面程序的输出结果

class A {
public:
	A(){}
	virtual void func() {
		cout << "A::func" << endl;
	}
	~A() {
	}
	virtual void fund() {
		cout << "A::fund" << endl;
	}
};
class B :public A {
public:
	B() {
		func();
	}
	void fun() {
		func();
	}
	~B() { fund(); }
};
class C :public B {
public:
	C(){}
	void func() {
		cout << "C::func" << endl;
	}
	~C() {
		fund();
	}
	void fund() {
		cout << "C::fund" << endl;
	}
};
int main() {
	C c;
	return 0;
}

程序内容

程序中包含了A,B,C三个类，A派生出B，B派生出C。

A类中包含什么都不做的构造函数与析构函数，此外其还包含能够打印相应内容的虚函数func()以及fund()。

B类包含构造函数以及析构函数，其中构造函数中包含func()，析构函数中包含fund()。除了析构与构造函数，还包含fun()函数，fun()函数中调用func()函数。

C类包含构造函数与析构函数，构造函数什么都不做，析构函数包含fund()。除此外，其还包含func()与fund()

主程序中定义了C类的对象c。

运行分析

在整个程序运行的过程中包含了C类对象c的构造与析构过程。

而由前面基础内容可得两个知识点：

1，同参同返回类型的函数一旦定义为虚函数，则派生类的同参同返回函数也为虚函数。

2，析构函数与析构函数不存在多态的现象。即编译时可以确定哪个调用哪个。如果本类有该函数，调用本类；如果没有，调用直接基类；如果直接基类没有，调用间接基类.

按照顺序，首先是A类构造，什么都不做

然后B类构造，调用本类func(),func()不存在则往上找到A的func(),输出A::func

接着C类构造，什么也不做。

然后反向顺序析构：

先析构C，调用fund(),输出 C::fund

在调用B, 调用本类fund(),不存在，则往上找，输出A::fund

最后调用A，什么也不做。

结果

因此输出顺序为

A::func

C::fund

A::fund

运行验证

further

这里可能会有个疑问：

1,把A的fund()删掉会怎么样？

那当然是报错了->显示未定义标识符

2,A类的virtual关键字去掉？

显然并没有影响，人还是活的好好的，继续调用

下面程序的输出结果为

destructor B

destructor A

请写出完整的class A,限制条件：不得为class A编写构造函数

class A{};
class B : public A {
public:
	~B() { cout << "destructor B" << endl; }
};
int main() {
	A*pa;
	pa = new B;
	delete pa;
	return 0;
}

这个有点弱鸡，直接是书写虚构造函数。不写的话就直接是destructor B的输出了

class A{
public:
	virtual ~A() {
		cout<< "destructor A" << endl;
	}
};

下面程序的输出结果是

A::Fun

A::Do

A::Fun

C::Do

请填空

class A {
private:
	int nVal;
public:
	void Fun() {
		cout << "A::Fun" << endl;
	}
	virtual void Do() {
		cout << "A::Do" << endl;
	}
};
class B :public A {
public:
	virtual void Do() {
		cout << "B::Do" << endl;
	}
};
class C :public B {
public:
	void Do()
	{
		cout << "C::Do" << endl;
	}
	void Fun() {
		cout << "C::Fun" << endl;
	}
};
void Call(_______) {
	p->Fun(); p->Do();
}
int main() {
	Call(new A());
	Call(new C());
	return 0;
}