第六讲：多态

目录

• 派生类中和基类中虚函数同名同参数的函数，不加virtual也自动成为虚函数：
• 如果基类指针指向派生类对象：
• 第六讲习题：
  • A：看上去像多态
  • B：Fun和Do
  • C：这是什么鬼delete
  • D：怎么又是Fun和Do

派生类中和基类中虚函数同名同参数的函数，不加virtual也自动成为虚函数：

1.1.这里的虚函数需要加在基类，派生类的同名同参数函数才自动生成虚函数。
2.1.如果基类没有加virtual关键字，派生类加了也不能生成虚函数。
3.1.如果基类和派生类的函数都没有加virtual关键字，则调用的函数取决于当前指针指向的对象是基类对象还是派生类对象。（没有用到多态）

如果基类指针指向派生类对象：

指针调用函数时会首先考虑基类函数，如果基类函数是虚函数，才会考虑调用其指向的派生类对象中的同名函数。

第六讲习题：

A：看上去像多态

题目链接：http://cxsjsx.openjudge.cn/hw202006/A/

#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:
        D( int n):B(3*n){nDVal=n;}
        void Fun()
        {cout<<"D::Fun"<<endl;}
        void Print()
        {
            B::Print();
            cout<<"nDVal="<<nDVal<<endl;
        }
};
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;
}

B：Fun和Do

题目链接 ：http://cxsjsx.openjudge.cn/hw202006/B/

#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() //B相对与C是基类，使得C中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()，那么由于类B中没有该函数，只好找继承的A中的函数。之后调用调用Do使先考虑B自身的，但由于有virtual关键字，考虑到引用的是一个C类对象，于是调用C类虚函数。
{ 
	p.Fun(); p.Do(); 
} 
int main() { 
	C c; 
	Call( c); 
	return 0;
}

C：这是什么鬼delete

题目链接：http://cxsjsx.openjudge.cn/hw202006/C/

#include <iostream> 
using namespace std;
class A 
{ 
public:
	A() { }
    virtual ~A(){ cout<<"destructor A"<<endl;}//这是虚析构函数的一个例子，基类析构函数前➕virtual，能保证析构一个派生类对象时，先调用派生类析构函数，再调用基类析构函数。
}; 
class B:public A { 
	public: 
	~B() { cout << "destructor B" << endl; } 
}; 
int main() 
{ 
	A * pa; //如果这里是B*指针，就会自动调用派生类析构函数再调用基类析构函数，无虚析构函数的烦恼。
	pa = new B; 
	delete pa; 
	return 0;
}

D：怎么又是Fun和Do

题目链接：http://cxsjsx.openjudge.cn/hw202006/D/

#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()); //A::Fun A::Do
	Call( new C());//A::Fun C::Do 首先考虑Fun和Do能否在基类函数中输出，如果有virtual关键字，再去找它所指向相应对象派生类的函数！
	return 0;
}