走进C++程序世界-----继承和派生（2）

覆盖基类的函数

    覆盖基类函数顾名思义就是在派生类中对基类的函数进行的重新定义。这里将会讲到下面的2个知识点：

1、隐藏基类的方法

2、调用基类的方法（隐式和显示调用基类的方法）

 

/*

 *derive2.cpp

 *Date : 2013-9-24

 *Author: sjin

 *Mail:[email protected]

 */

#include <iostream>

#define N 0





using namespace std;



/*知识点：

 * 1、隐藏基类的方法（就是在派生类中重新实现函数的定义）

 * 2、当基类的方法被覆盖时，仍可通过限定方法名来调用它，如下格式：

 *    baseclass::Method();

 */



/*基类*/

class Manmal{

public:

    //Manmal():itsAge(2),itsWeight(5){ cout << " create Manmal object..."<<endl;}

    //~Manmal(){cout << " destroy Manmal object..."<<endl;}

    

    void Move() const { cout << "Manmal move one step..." << endl;}

    void Move(int distance) const

    {

        cout << "Manmal Move '" << distance << "' steps..." << endl;

    }



private:

    int itsAge;

    int itsWeight;

};



/*派生类*/

class Dog : public Manmal {

public:

    //Dog() {cout << " create Dog object..." << endl;}

    //~Dog() {cout << " destroy Dog object..."<< endl;}



    /*隐藏了基类的Move()方法*/

    void Move() const 

    { 

        cout << "Dog move 5 steps..." << endl;

        cout << "隐式调用基类方法(start):" << endl;

        Manmal::Move();

        Manmal::Move(1000);

        cout << "隐式调用基类方法(end):" << endl;

    }



};



int main()

{

    Manmal bigAnimal;

    Dog Fido;

    cout << "**********Manmal bigAnimal*************" << endl;

    bigAnimal.Move();

    bigAnimal.Move(2);

    cout << "**********Dog Fido*************" << endl;

    Fido.Move();

    //Fido.Move(2);

    /* 上面将会出现下面的错误

     * derive2.cpp:56: error: no matching function for call to ‘Dog::Move(int)’

     * derive2.cpp:43: note: candidates are: void Dog::Move() const

     * 也就是说： 覆盖任一个重载的方法后，该方法的其他所有版本都会被隐藏。

     *            如果补希望他们被隐藏，必须对其进行覆盖。

     */

    

    /*显式调用被隐藏基类的方法*/

    cout << "显式调用基类方法(start):" << endl;

    Fido.Manmal::Move();

    Fido.Manmal::Move(200);

    cout << "显式调用基类方法(end):" << endl;

     



}

输出如下：

**********Manmal bigAnimal*************

Manmal move one step...

Manmal Move '2' steps...

**********Dog Fido*************

Dog move 5 steps...

隐式调用基类方法(start):

Manmal move one step...

Manmal Move '1000' steps...

隐式调用基类方法(end):

显式调用基类方法(start):

Manmal move one step...

Manmal Move '200' steps...

显式调用基类方法(end):

    虚方法 

DOG对象是一个Manmal对象，因此这就意味着Dog对象继承了基类的属性和功能。C++扩展了其多态性，允许将派生类对象赋给指向基类的指针。因此，可以这样编写代码：

Manmal * pManmal = new Dog;

上面的代码创建了一个新的Dog对象，并返回了一个指向该对象的指针，然后将该指针赋给一个Manmal指针。之所以可以这样做，是因为狗也是一种动物。如果希望在调用被Dog覆盖的方法是，将调用正确的函数，虚函数让你能够做到这一点，要创建虚函数，在函数声明前加上关键字Virtual。看下面的代码：

/*

 *virtual.cpp

 *Date : 2013-9-20

 *Author: sjin

 *Mail:[email protected]

 */

#include <iostream>

using namespace std;



/*知识点：

 * 1、如何创建虚函数？

 *    在函数声明前加上virtual 关键字

 * 2、使用虚方法的意义

 *    基类中如果声明了虚方法，说明它的派生类中有可能会覆盖这个方法。

 * 3、如果在基类中将一个成员方法标记为虚方法，还需要在派生类中将它标记为虚方法吗？

 *    不需要，方法被声明为虚方法后，如果在派生类覆盖它，它仍是虚方法。在派生类继续

 *    将其标记为虚方法是个不错的主意，但是没有必要这么作，这样使代码更容易理解。

 * */



class Manmal {

public:

    Manmal():itsAge() { cout << "Manmal constrctor...\n";}

    virtual ~Manmal() { cout << "Manmal destructor...\n";}

    void Move() const { cout << "Manmal move one step\n";}

    virtual void Speak() const { cout << "Manmal speak!\n";}



protected:

    int itsAge;

};



class Dog :public Manmal{

public:

    Dog() { cout << " Dog constrctor...\n";}

    virtual ~Dog() { cout << " Dog destructor..\n";}

    void WagTail() { cout << " Wagging Tail...\n";}

    void Speak() const { cout << "Dog woof!\n";}

    void Move() const { cout << "Dog moves 5 steps ...\n";}

};



int main()

{

    /*创建一个信的dog对象，并返回该对象的指针，然后将该指针付给一个

     * Manmal指针。

     * 这是多态的本质，例如：可创建很多类型的窗口，包括对话框，可滚动

     * 窗库和列表框，然后给每种窗口定义一个虚方法draw().通过创建一个窗口指针，

     * 并将对话框和其他的派生对象赋給指针，就可以通过调用draw()，而不用考虑运行

     * 时指针只想的实际对象类型，程序将调用正确的draw()方法。

     * */



    Manmal *pDog = new Dog;

    pDog->Move();

    pDog->Speak();/*虚方法，被覆盖*/

    /*释放对象*/

    delete pDog;

    return 0;

}

输出：

Manmal constrctor...

 Dog constrctor...

Manmal move one step

Dog woof!

 Dog destructor..

Manmal destructor...

从上面的输出可以看到，Manmal 指针pDog ，调用了Dog类的SPEAK（）方法，这里很神奇！但是Move（）函数调用的仍然是manmal类的方法。