《程序设计实习》之【多态与虚函数】

最新推荐文章于 2024-05-21 12:00:00 发布

beashaper_

最新推荐文章于 2024-05-21 12:00:00 发布

阅读量555

点赞数 1

分类专栏： C++

本文链接：https://blog.csdn.net/beashaper_/article/details/80637488

版权

C++ 专栏收录该内容

48 篇文章 2 订阅

订阅专栏

虚函数和多态
多态程序实例
多态的实现原理
虚析构函数
纯虚函数和抽象类

虚函数和多态

虚函数

在类的定义中，前面有 virtual 关键字的成员函数就是虚函数。

class base { 
    virtual int get(); 
}; 
int base::get() {}

virtual 关键字只用在类定义里的函数声明中，写函数体时不用。

多态的表现形式一

派生类的指针可以赋给基类指针
通过基类指针调用基类和派生类中的同名虚函数时：
- 若该指针指向一个基类的对象，那么被调用的是基类的虚函数
- 若该指针指向一个派生类的对象，那么被调用的是派生类的虚函数
这种机制就叫做“多态”

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;
}

多态的表现形式二

派生类的对象可以赋给基类引用
通过基类引用调用基类和派生类中的同名虚函数时：
- 若该引用引用的是一个基类的对象，那么被调用的是基类的虚函数
- 若该引用引用的是一个派生类的对象，那么被调用的是派生类的虚函数
这种机制也叫做“多态”

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 A {
public :
    virtual void Print( ) { cout << "A::Print"<<endl ; }
};

class B: public A {
public :
    virtual void Print( ) { cout << "B::Print" <<endl; }
};

class D: public A {
public:
    virtual void Print( ) { cout << "D::Print" << endl ; }
};

class E: public B {
    virtual void Print( ) { cout << "E::Print" << endl ; }
};

int main() {
    A a; B b;
    E e; D d;
    A * pa = &a; B * pb = &b;
    D * pd = &d ; E * pe = &e;
    pa->Print();   // a.Print()被调用，输出：A::Print
    pa = pb;
    pa -> Print(); //b.Print()被调用，输出：B::Print
    pa = pd;
    pa -> Print(); //d. Print ()被调用,输出：D::Print
    pa = pe;
    pa -> Print(); //e.Print () 被调用,输出：E::Print
    return 0;
}

多态的作用

在面向对象的程序设计中使用多态，能够增强程序的可扩充性，即程序需要修改或增加功能的时候，需要改动和增加的代码较少。

多态程序实例

几何形体处理程序

几何形体处理程序: 输入若干个几何形体的参数，要求按面积排序输出。输出时要指明形状。

Input:
第一行是几何形体数目n（不超过100).下面有n行，每行以一个字母c开头.
若 c 是 ‘R’，则代表一个矩形，本行后面跟着两个整数，分别是矩形的宽和高；
若 c 是 ‘C’，则代表一个圆，本行后面跟着一个整数代表其半径
若 c 是 ‘T’，则代表一个三角形，本行后面跟着三个整数，代表三条边的长度

Output:
按面积从小到大依次输出每个几何形体的种类及面积。每行一个几何形体，输出格式为：
形体名称：面积

Sample Input:
3
R35
C9
T345

Sample Output
Triangle:6
Rectangle:15
Circle:254.34

#include <iostream>
#include <stdlib.h>
#include <cmath>
using namespace std;
class CShape {
public:
    virtual double Area() = 0;   // 纯虚函数
    virtual void PrintInfo() = 0;
};
class CRectangle:public CShape {
public:
    int w, h;
    virtual double Area();
    virtual void PrintInfo();
};
class CCircle:public CShape {
public:
    int r;
    virtual double Area();
    virtual void PrintInfo();
};

class CTriangle:public CShape {
public:
    int a, b, c;
    virtual double Area();
    virtual void PrintInfo();
};

double CRectangle::Area() {
    return w * h;
}
void CRectangle::PrintInfo() {
    cout << "Rectangle:" << Area() << endl;
}
double CCircle::Area() {
    return 3.14 * r * r ;
}
void CCircle::PrintInfo() {
    cout << "Circle:" << Area() << endl;
}
double CTriangle::Area() {
    double p = (a+b+c)/2.0;
    return sqrt(p*(p-a)*(p-b)*(p-c));
}
void CTriangle::PrintInfo() {
    cout << "Triangle:" << Area() << endl;
}
CShape * pShapes[100];
int MyCompare(const void * s1, const void * s2) {
    double a1, a2;                  // s1,s2 是 void * ，不可写 “* s1”来取得s1指向的内容
    CShape ** p1 = (CShape**) s1;   // s1,s2指向pShapes数组中的元素，数组元素的类型是CShape *
    CShape ** p2 = (CShape**) s2;   // 故 p1,p2都是指向指针的指针，类型为 CShape **
    a1 = (*p1)->Area();             // * p1 的类型是 Cshape * ,是基类指针，故此句为多态
    a2 = (*p2)->Area();
    if( a1 < a2 )
        return -1;
    else if ( a2 < a1 )
        return 1;
    else
        return 0;
}

int main() {
    int i; int n;
    CRectangle * pr;
    CCircle * pc;
    CTriangle * pt;
    cin >> n;
    for( i = 0; i < n; i++ ) {
        char c;
        cin >> c;
        switch(c) {
            case 'R':
                pr = new CRectangle();
                cin >> pr->w >> pr->h;
                pShapes[i] = pr;
                break;

            case 'C':
                pc = new CCircle();
                cin >> pc->r;
                pShapes[i] = pc;
                break;

            case 'T':
                pt = new CTriangle();
                cin >> pt->a >> pt->b >> pt->c;
                pShapes[i] = pt;
                break;
        }
    }  
    qsort(pShapes, n, sizeof( CShape*), MyCompare); 
    for( i = 0;i <n;i ++)     
        pShapes[i]->PrintInfo(); 
    return 0; 
}

如果添加新的几何形体，比如五边形，则只需要从CShape派生出CPentagon，以及在main中的 switch语句中增加一个case，其余部分不变。

用基类指针数组存放指向各种派生类对象的指针，然后遍历该数组，就能对各个派生类对象做各种操作，是很常用的做法。

多态的又一例子

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()

在非构造函数，非析构函数的成员函数中调用虚函数，是多态!!!
此时指针指向的是Derived对象，所以调用的就是该派生对func1()（从父类继承来的）。

构造函数和析构函数中调用虚函数

在构造函数和析构函数中调用虚函数，不是多态。编译时即可确定，调用的函数是自己的类或基类中定义的函数，不会等到运行时才决定调用自己的还是派生类的函数。

#include <iostream>
using namespace std;
class myclass {
public:
    virtual void hello() { cout << "hello from myclass" << endl; }
    virtual void bye() { cout << "bye from myclass" << endl; }
    myclass() { hello(); }
    ~myclass() { bye(); }

};
class son:public myclass {
public:
    void hello() { cout << "hello from son" << endl; }
    void bye() { cout << "bye 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 myclass
hello from son
constructing grandson
hello from grandson
destructing grandson
bye from son
bye from myclass

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

多态的实现原理

“多态”的关键在于通过基类指针或引用调用一个虚函数时，编译时不确定到底调用的是基类还是派生类的函数，运行时才确定 —- 这叫“动态联编”。“动态联编” 底是怎么实现的呢？请看下面例子程序：

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; }
};
int main() {
    Derived d;
    cout << sizeof( Base) << ","<< sizeof( Derived ) ;
    return 0;
}

程序运行输出结果：

8， 12

为什么都多了4个字节？

多态实现的关键 – 虚函数表

每一个有虚函数的类（或有虚函数的类的派生类）都有一个虚函数表，该类的任何对象*中都放着虚函数表的指针。虚函数表中列出了该类的虚函数地址，多出来的4个字节就是用来放虚函数表的地址的。

pBase = pDerived;
pBase->Print();

多态的函数调用语句被编译成一系列根据基类指针所指向的（或基类引用所引用的）对象中存放的虚函数表的地址，在虚函数表中查找虚函数地址，并调用虚函数的指令。

虚析构函数

class son{
public:
    ~son() { cout << "bye from son" << endl; }
};

class grandson : public son{
public:
    ~grandson(){ cout << "bye from grandson" << endl; }

};

int main(){
    son *pson;
    pson = new grandson;
    delete pson;
    return 0;
}

输出结果：

bye from son

没有执行grandson::~grandson()!!!

问题：
通过基类的指针删除派生类对象 时 -> 只调用基类的析构函数
希望：
删除一个派生类的对象时 -> 先调用派生类的析构函数 -> 再调用基类的析构函数

解决办法：

把基类的析构函数声明为virtual
- 派生类的析构函数virtual可以不进行声明
- 通过基类的指针删除派生类对象时
  - 先调用派生类的析构函数
  - 然后调用基类的析构函数
类如果定义了虚函数，则最好将析构函数也定义成虚函数

注意: 不允许以虚函数作为构造函数

class son{
public:
    virtual ~son() { cout << "bye from son" << endl; };
};

class grandson : public son{
public:
    ~grandson(){ cout << "bye from grandson" << endl; };
};

int main() {
    son *pson;
    pson= new grandson;
    delete pson;
    return 0;
}

输出结果：

bye from grandson
bye from son

执行grandson::~grandson(),引起执行son::~son()
* 纯虚函数和抽象类

纯虚函数和抽象类

纯虚函数：没有函数体的虚函数

class A {
private:
    int a;
public:
    virtual void Print() = 0;   // 纯虚函数
    void fun() { cout << "fun"; }
};

抽象类

抽象类：包含纯虚函数的类

只能作为基类来派生新类使用
不能创建抽象类的对象
抽象类的指针和引用可以指向或引用由抽象类派生出来的类的对象

A a;        // 错, A 是抽象类, 不能创建对象
A * pa;     // ok, 可以定义抽象类的指针和引用
pa = new A; //错误, A 是抽象类, 不能创建对象

纯虚函数和抽象类

在抽象类中：
- 在成员函数内可以调用纯虚函数
- 在构造函数/析构函数内部不能调用纯虚函数
如果一个类从抽象类派生而来
- 它实现了基类中的所有纯虚函数，才能成为非抽象类

class A {
public:
    virtual void f() = 0; //纯虚函数
    void g( ) { this->f( ); } //ok
    A( ){ } // A( ){ f( ); } 错误
};

class B : public A{
public:
    void f(){ cout<<"B: f()"<<endl; }
};

int main(){
    B b;
    b.g();
    return 0;
}

输出结果：

B: f()

beashaper_

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
《程序设计实习》之【多态与虚函数】

虚函数和多态多态程序实例多态的实现原理虚析构函数纯虚函数和抽象类虚函数和多态虚函数在类的定义中，前面有 virtual 关键字的成员函数就是虚函数。class base { virtual int get(); }; int base::get() {}virtual 关键字只用在类定义里的函数声明中，写函数体时不用。多态的表现形式一...
复制链接

扫一扫

专栏目录