C++ 多态 001:看上去像多态 002:Fun和Do 003:这是什么鬼delete 004:怎么又是Fun和Do

001:看上去像多态

描述
程序填空产生指定输出

#include <iostream>
using namespace std;
class B { 
	private: 
		int nBVal; 
	public: 
		void Print() 
		{ cout << "nBVal="<< nBVal << endl; } 
		void Fun() 
		{cout << "B::Fun" << endl; } 
		B ( int n ) { nBVal = n;} 
};
// 在此处补充你的代码
int main() { 
	B * pb; D * pd; 
	D d(4); d.Fun(); 
	pb = new B(2); pd = new D(8); 
	pb -> Fun(); pd->Fun(); 
	pb->Print (); pd->Print (); 
	pb = & d; pb->Fun(); 
	pb->Print(); 
	return 0;
}

输入
无
输出

D::Fun
B::Fun
D::Fun
nBVal=2
nBVal=24
nDVal=8
B::Fun
nBVal=12

解题
分析输出

int main() { 
	B * pb; D * pd; 
	D d(4); d.Fun(); 
			//D::Fun
	pb = new B(2); pd = new D(8); 
	pb -> Fun(); pd->Fun(); 
	//B::Fun  	//D::Fun
	pb->Print (); pd->Print (); 
	//nBVal=2   //nBVal=24  nDVal=8
	pb = & d; pb->Fun(); 
			//B::Fun
	pb->Print();   
	//nBVal=12
	return 0;
}

pb为B类型，指向new B(2), pb->Fun调用B类型函数，输出B::Fun
pd为D类型，指向new D(8),pdf->Fun调用D类型函数，输出D::Fun
d(4)为 D 类型，d.Func()，调用D的函数，输出D::Fun
故func函数不为多态
pb->Print——输出pb的nBVal=2
pd->Print——输出nDVal的同时，输出了nBVal，故需要修改Print函数
pb=&d,即d的地址，B * 类型的指针指向了D * 类型，pb->Fun依旧是B::Fun，说明dun不为多态
pb->Print() 值为3倍的n，派生类赋值父类，因为print不是虚函数，所以调用的时父类的print，而值为派生类的赋值。

补充的代码

#include <iostream>
using namespace std;
class B { 
	private: 
		int nBVal; 
	public: 
		void Print() 
		{ cout << "nBVal="<< nBVal << endl; } 
		void Fun() 
		{cout << "B::Fun" << endl; } 
		B ( int n ) { nBVal = n;} 
};
// 在此处补充你的代码
class D:public B{
	private:
		int nDVal;
	public:
		void Fun(){
			cout<<"D::Fun"<<endl;          
		}
		void Print()
		{
			B::Print();                      //直接调用父类的print函数 
			cout<<"nDVal="<<nDVal<<endl;
		}
		D ( int n ) :nDVal(n),B(3*n){}     //构造函数——无法访问B的private，则直接调用b的构造函数 
};
//
int main() { 
	B * pb; D * pd; 
	D d(4); d.Fun(); 
	pb = new B(2); pd = new D(8);       
	pb -> Fun(); pd->Fun();     //D::Fun       // B::Fun  D::Fun
	pb->Print (); pd->Print (); // nBVal=2      // nBVal=24 nDVal=8


	pb = & d; pb->Fun();  // B::Fun
	pb->Print();        // nBVal=12
	return 0;
}

002:Fun和Do

描述
程序填空输出指定结果

#include <iostream> 
using namespace std;
class A { 
	private: 
	int nVal; 
	public: 
	void Fun() 
	{ cout << "A::Fun" << endl; }; 
	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() { 
	C c; 
	Call( c); 
	return 0;
}

输入
无
输出

A::Fun
C::Do

分析输出

Call( c); 

调用了 A::Fun 以及 C::Do
故Fun为基类的函数，do为派生类C的函数
B类的Do为虚函数，且B类无Fun函数
故call（B类对象）即可调用基类的Fun和多态的Do

//原题
#include <iostream> 
using namespace std;
class A {
private:
	int nVal;
public:
	void Fun()
	{
		cout << "A::Fun" << endl;
	};
	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(B &p
	// 在此处补充你的代码
) {
	p.Fun(); p.Do();
}
int main() {
	C c;
	Call(c);
	system("pause");
	return 0;
} 

上述为引用对象调用多态，如下为指针对象调用多态

#include <iostream> 
using namespace std;
class A { 
	private: 
	int nVal; 
	public: 
	void Fun() 
	{ cout << "A::Fun" << endl; };         //调用 
	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(
// 在此处补充你的代码
B *p          //B引用 
// 
) { 
	p->Fun(); p->Do();     //A的fun，c的do 
} 
int main() { 
	B *b=new C();       //B* 类指向 C类动态对象
	Call( b);           //A::Fun   
						//C::Do  
	return 0;
}

003:这是什么鬼delete

描述
程序填空输出指定结果

#include <iostream> 
using namespace std;
class A 
{ 
public:
	A() { }
// 在此处补充你的代码
}; 
class B:public A { 
	public: 
	~B() { cout << "destructor B" << endl; } 
}; 
int main() 
{ 
	A * pa; 
	pa = new B; 
	delete pa; 
	return 0;
}

输入
无
输出

destructor B
destructor A

分析输出
先调用B的析构函数
再调用A的析构函数
故需为基类A添加虚析构函数
这样析构A *对象时，会先调用指针指向的派生类对象的析构函数

#include <iostream> 
using namespace std;
class A 
{ 
public:
	A() { }
// 在此处补充你的代码
virtual ~A(){
	cout<<"destructor A"<<endl;
}
//
}; 
class B:public A { 
	public: 
	~B() { cout << "destructor B" << endl; }          //
}; 
int main() 
{ 
	A * pa;      
	pa = new B;              				
	delete pa;               
	return 0;
}

004:怎么又是Fun和Do

描述
程序填空输出指定结果

#include <iostream>
using namespace std;
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;
}

输入
无
输出

A::Fun
A::Do
A::Fun
C::Do

分析输出
A的Do函数也为虚函数，故Call(new A())一定会调用A的do函数
同理 call（newC（））也会调用C的do函数
而func函数不为虚函数，故无多态，只调用A类fun，说明call参数为B类，根据下列指针操作，为B*指针

#include <iostream>
using namespace std;
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(
// 在此处补充你的代码
A*p 
// 
) {
	p->Fun(); p->Do();
}
int main() {
	Call( new A());      
	Call( new C());
	return 0;
}