C++面向对象程序设计的一些知识点（3）

摘要：多态性提供一组统一的调用接口函数，依据这些条用接口函数具体对象的不同，同一名字的函数会有不同的行为。

1、重载与隐藏

（1）、对同一作用域中的同名函数，如果它们的函数特征标不同，那么它们就形成一种重载关系。

（2）、基类与派生类中非虚同名函数，不管它们的参数特征标是否相同，它们都形成隐藏关系，即派生类对象隐藏基类中的同名函数。

#include <iostream>

using namespace std;

class Animal
{
public:
    void walk()
    {
        cout << "Animal walk.\n";
    }
    void walk(int walkWay)
    {
        switch(walkWay)
        {
        case 0:
            cout << "Animal jump...\n";
            break;
        case 1:
            cout << "Animal fly...\n";
            break;
        default:
            cout << "Animal scrawling...\n";
        }
    }
    void sleep()
    {
        cout << "Animal sleeping..." << endl;
    }
};
class Human:public Animal
{
public:
    void sleep()
    {
        cout << "Human sleep, lying...\n";
    }
};

int main()
{
    Animal *pAnimal = NULL;
    Animal animal;
    Human human;

    pAnimal = &animal;
    pAnimal->sleep();

    pAnimal = &human;
    pAnimal->sleep();

    Human *pHuman = &human;
    pHuman->sleep();

    pHuman->walk(1);
    pHuman->walk();

    int c;
    cin >> c;
    return 0;
}

（3）、在此示例代码中，同一类中的成员函数walk()与walk(int walkWay)形成重载。

（4）、分别位于基类Animal与派生类Human中的成员函数sleep()形成隐藏关系，即派生类Human的sleep()隐藏了基类的Animal中成员函数sleep()。

（5）、依据基类和派生类的兼容性原则，可以将派生类Human对象human的地址赋值给基类Animal的指针pAnimal。不过这时pAnimal指向的函数永远是基类的成员函数。

（6）、由于派生类Human的sleep()隐藏了基类Animal中的成员函数sleep()，所以pHuman->sleep()调用派生类Human的sleep()。

（7）、注意：基类指针永远无法调用该基类派生的同名函数。

2、多态性

（1）、虚函数：若类的成员函数用关键字virtual修饰，则称该函数为该类的虚函数，其声明语法如下：

virtual 返回值类型 函数名（形参列表）；

例如：

class Animal

{

public:

　　virtual void sleep()

　　{

　　　　cout << "Animal sleep." << endl;

　　}

};

（2）、函数覆盖：若位于基类和派生类中的两个同名虚函数的声明完全相同（包括返回值类型），则这样的两个函数形成覆盖关系。

例如：

class Pet

{

　　virtual void sleep()

　　{

　　　　cout << "Pet sleep." << endl;

　　}

};

class Fish:public Pet

{

　　virtual viod sleep()

　　{　　

　　　　cout << "Fish sleep." << endl;

　　}

};

（3）、多态性实现步骤：

1）、在基类中说明成员函数为virtual函数，在直接派生类或间接派生类中根据实际应用重写这些virtual函数。

2）、在直接派生类或间接派生类中覆盖那些virtual函数，它们的声明必须和基类对应的虚函数声明严格一致。

3）、声明基类指针或者基类引用；给基类指针或者引用赋值，此时对象地址既可以是基类对象地址，也可以是派生类对象地址；有指针或者引用去调用相应的virtual函数，

根据对象的不同，真正被调用的函数可以是基类同名函数，也可以是派生类同名函数。

#include <iostream>

using namespace std;

class Animal
{
public:
    virtual void walk()
    {
        cout << "Animal walk." << endl;
    }
    void walk(int walkWay)
    {
        switch(walkWay)
        {
        case 0:
            cout << "Animal jump..." << endl;
            break;
        case 1:
            cout << "Animal fly..." << endl;
            break;
        default:
            cout << "Animal scraling..." << endl;
        }
    }
    virtual void sleep()
    {
        cout << "Animal sleeping..." << endl;
    }
private:
};

class Human:public Animal
{
public:
    virtual void walk()
    {
        cout << "Human walk by feet." << endl;
    }
    virtual void sleep()
    {
        cout << "Human sleep, lying..." << endl;
    }
    virtual void talk()
    {
        cout << "Human talking..." << endl;
    }
private:
};
int main()
{
    Animal *pAnimalArray[] = {
        new Animal, new Human
    };
    for(int i = 0;i < 2;i++)
    {
        pAnimalArray[i]->walk();
        pAnimalArray[i]->sleep();
        delete pAnimalArray[i];
    }
    int c;
    cin >> c;
    return 0;
}

（4）、注意：若在类中只声明虚函数原型，则在类外部定义虚函数时不必加virtual关键字；若派生类覆盖基类某个虚函数，则派生类中对应的虚函数可以加virtual也可以

加；一个虚函数，他在直接派生类和间接派生类中依然保持虚函数的特性；虚函数必须是成员函数；只有通过指针或引用方式访问虚函数，才能获得虚函数的动态特性。

 3、virtual析构函数

（1）、通常，我们会才用基类指针或引用来指向派生类对象，此时，使用delete释放堆中的对象时，只会释放其基类子对象部分而不会自动释放派生类子对象部分。解决

办法是把基类和派生类的析构函数都声明为virtual类型。

#include <iostream>

using namespace std;

class Vehicle
{
public:
    Vehicle(int power)
    {
        this->power = power;
    }
    virtual ~Vehicle()
    {
        cout << "deleting Vehicle sub object..." << endl;
    }
public:
    virtual void run()
    {
        cout << "Vehicle running..." << endl;
    }
private:
    int power;
};
class Plane:public Vehicle
{
public:
    Plane(int power, double height):Vehicle(power)
    {
        this->height = height;
    }
    virtual ~Plane()
    {
        cout << "deleting Plane sub object..." << endl;
    }
public:
    void run()
    {
        cout << "Plane fly..." << endl;
    }
private:
    double height;
};
int main()
{
    {
        Vehicle *pVehicle = new Plane(30, 3005);
        delete pVehicle;
    }
    int c;
    cin >> c;
    return 0;
}

4、纯虚函数和抽象类

（1）、纯虚函数：类中的virtual成员函数，如果没有实现体（即定义实现体为0），则称这样的函数为纯虚函数。

例如：

virtual void add()=0;

（2）、抽象类：当一个类含有一个或者多个纯虚函数时，称这样的类为抽象类。

注意：抽象类的纯虚函数可以是我们后续加入的或者从基类继承的，当然如果一个类继承一个或多个纯虚函数之后再一一实现这些纯虚函数，那么这样的类不再是抽象类；

抽象类不能用于创建对象，但允许定义抽象对象指针。

#include <iostream>

using namespace std;

const double PI = 3.14159;

class Shape
{
public:
    virtual void show() = 0;
    virtual double area() = 0;
    virtual ~Shape()
    {}
};
class Shape2D:public Shape
{
public:
    Shape2D(double x, double y)
    {
        this->x = x;
        this->y = y;
    }
protected:
    double x;
    double y;
};
class Shape3D:public Shape
{
public:

protected:
    double x;
    double y;
    double z;
};
class Circle:public Shape2D
{
public:
    Circle(double x, double y, double radius):Shape2D(x, y)
    {
        this->radius = radius;
    }
    virtual void show()
    {
        cout << "Circle center: (" << x << ", " << y << ")" << endl;
    }
    virtual double area()
    {
        return PI*radius*radius;
    }
private:
    double radius;
};
class Sphere:public Shape3D
{
public:
    Sphere(double x, double y, double z, double radius)
    {
        this->x = x;
        this->y = y;
        this->z = z;
        this->radius = radius;
    }
    void show()
    {
        cout << "Sphere center:(" << x << ", " << y << ", " << z << ")" << endl;
    }
    double area()
    {
        return PI*radius*radius*radius;
    }
private:
    double radius;
};
int main()
{
    {
        Shape *pShape = NULL;
        Shape *pShapeArray[] = {
            new Circle(1.0, 2.0, 3.0),
            new Sphere(1.0, 2.0, 3.0, 4.0)
        };
        for(int i = 0;i < 2;i++)
        {
            pShapeArray[i]->show();
            cout << "\t area = " << pShapeArray[i]->area() << endl;
            delete pShapeArray[i];
        }
    }
    int c;
    cin >> c;
    return 0;
}