这一周的内容主要是介绍虚函数与多态。

课程地址:

coursera:C++程序设计

https://www.coursera.org/learn/cpp-chengxu-sheji

中国大学MOOC:程序设计与算法(三)C++面向对象程序设计

程序设计与算法(三)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()