Coursera Cpp程序设计 week 5
这一周的内容主要是介绍虚函数与多态。
课程地址：
coursera：C++程序设计
https://www.coursera.org/learn/cpp-chengxu-sheji
中国大学MOOC：程序设计与算法（三）C++面向对象程序设计
虚函数
在类的定义中，前面有virtual关键字的成员函数就是虚函数，virtual 关键字只用在类定义里的函数声明中，写函数体时不用。
class base {
virtual int get() ;
};
int base::get()
{ }
多态的表现形式一
派生类的指针可以赋给基类指针。
通过基类指针调用基类和派生类中的同名虚函数时:
（1）若该指针指向一个基类的对象，那么被调用是基类的虚函数；
（2）若该指针指向一个派生类的对象，那么被调用的是派生类的虚函数。
这种机制就叫做“多态”。
例子：
class CBase {
public:
virtual void SomeVirtualFunction() { }
};
class CDerived:public CBase {
public :
virtual void SomeVirtualFunction() { }
};
int main() {
CDerived ODerived;
CBase * p = & ODerived;
p -> SomeVirtualFunction(); //调用哪个虚函数取决于p指向哪种类型的对象
return 0;
}多态的表现形式二
- 派生类的对象可以赋给基类引用
- 通过基类引用调用基类和派生类中的同名虚函数时:
- （1）若该引用引用的是一个基类的对象，那么被调用是基类的虚函数；
- （2）若该引用引用的是一个派生类的对象，那么被调用的是派生类的虚函数。
这种机制也叫做“多态”。
例子：
class CBase {
public:
virtual void SomeVirtualFunction() { }
};
class CDerived:public CBase {
public :
virtual void SomeVirtualFunction() { }
};
int main() {
CDerived ODerived;
CBase & r = ODerived;
r.SomeVirtualFunction(); //调用哪个虚函数取决于r引用哪种类型的对象
return 0;
} 多态的例子
class Base {
public:
void fun1() { fun2(); }
virtual void fun2() { cout << "Base::fun2()" << endl; }
};
class Derived:public Base {
public:
virtual void fun2() { cout << "Derived:fun2()" << endl; }
};
int main() {
Derived d;
Base * pBase = & d;
pBase->fun1();
return 0;
}注意这个程序的输出结果为Derived:fun2()，这是因为Base类中fun1可以看为如下形式：
void fun1() { this->fun2(); }所以在非构造函数，非析构函数的成员函数中调用虚函数，是多态。而在构造函数和析构函数中调用虚函数，不是多态。因为编译时即可确定，调用的函数是自己的类或基类中定义的函数，不会等到运行时才决定调用自己的还是派生类的函数。
来看一个例子。
class myclass {
public:
virtual void hello(){cout<<"hello from myclass"<<endl;}
virtual void bye(){cout<<"bye from myclass"<<endl;}
};
class son:public myclass{
public:
void hello(){ cout<<"hello from son"<<endl;};
son(){ hello(); };
~son(){ bye(); };
};
class grandson:public son{ public:
void hello(){cout<<"hello from grandson"<<endl;};
void bye() { cout << "bye from grandson"<<endl;}
grandson(){cout<<"constructing grandson"<<endl;};
~grandson(){cout<<"destructing grandson"<<endl;};
};
int main(){
grandson gson;
son *pson;
pson=&gson;
pson->hello(); //多态
return 0;
}
'''
结果：
hello from son
constructing grandson
hello from grandson
destructing grandson
bye from myclass
'''注意派生类中和基类中虚函数同名同参数表的函数，不加virtual也自动成为虚函数。
多态的实现原理
“多态” 的关键在于通过基类指针或引用调用 一个虚函数时，编译时不确定到底调用的是基类还是派生类的函数，运行时才确定 —— 这叫“动态 联编” 。 “动态联编” 底是怎么实现的呢？来看一个例子。
#include <iostream>
using namespace std;
class Base {
public:
int i;
virtual void Print() { cout << "Base:Print" ; }
};
class Derived : public Base{
public:
int n;
virtual void Print() { cout <<"Drived:Print" << endl; }
};
class Base1 {
public:
int i;
void Print() { cout << "Base:Print" ; }
};
class Derived1 : public Base1{
public:
int n;
void Print() { cout <<"Drived:Print" << endl; }
};
int main() {
Derived d;
Base c;
cout << sizeof(Base) << ","<< sizeof(Derived) << endl;
cout << sizeof(Base1) << ","<< sizeof(Derived1) << endl;
return 0;
}
//程序运行输出结果：
//16,16
//4,8可以看到，有虚函数的类比没有虚函数的类多了几个字节，这是因为每一个有虚函数的类（或有虚函数的类的派生类）都有一个虚函数表，该类的任何对象中都放着虚函数表的指针。虚函数表中列出了该类的虚函数地址。
来看两张图：
我们再举一个例子证实上面一点：
#include <iostream>
using namespace std;
class A {
public:
virtual void Func() { cout << "A::Func" << endl; }
};
class B:public A {
public:
virtual void Func() { cout << "B::Func" << endl; }
};
int main() {
A a;
A * pa = new B();
pa->Func();
//64位程序指针为8字节
long long * p1 = (long long * ) & a;
long long * p2 = (long long * ) pa;
* p2 = * p1;
pa->Func();
return 0;
}
//输出结果
//B::Func
//A::Func虚析构函数
- 通过基类的指针删除派生类对象时，通常情况下只调用基类的析构函数
- 但是，删除一个派生类的对象时，应该先调用派生类的析构函数，然后调用基类的析构函数。
- 解决办法：把基类的析构函数声明为virtual
- 派生类的析构函数可以virtual不进行声明
- 通过基类的指针删除派生类对象时，首先调用派生类的析构函数，然后调用基类的析构函数
- 一般来说，一个类如果定义了虚函数，则应该将析构函数也定义成虚函数。或者，一个类打算作为基类使用，也应该将析构函数定义成虚函数。
- 注意： 不允许以虚函数作为构造函数。
纯虚函数和抽象类
纯虚函数：没有函数体的虚函数。
class A {
private: int a;
public:
virtual void Print( ) = 0 ; //纯虚函数
void fun() { cout << "fun"; }
};包含纯虚函数的类叫抽象类
抽象类只能作为基类来派生新类使用，不能创建独立的抽象类的对象。
抽象类的指针和引用可以指向由抽象类派生出来的类的对象。
```cpp
a ; // 错， A 是抽象类，不能创建对象
A * pa ; // ok,
pa = new A ; //错误, A 是抽象类，不能创建对象- 在抽象类的成员函数内可以调用纯虚函数，但是在构造函数或析构函数内部不能调用纯虚函数。 - 如果一个类从抽象类派生而来，那么当且仅当它实现了基类中的所有纯虚函数，它才能成为非抽象类。 来看一个例子： ```cpp class A { public: virtual void f() = 0; //纯虚函数 void g( ) { this->f( ) ; //ok } A( ){ //f( ); // 错误 } }; class B:public A{ public: void f(){cout<<"B:f()"<<endl; } }; int main(){ B b; b.g(); return 0; } //输出： //B:f()