码迷,mamicode.com
首页 > 编程语言 > 详细

C++--第17课 - 继承与多态 - 上

时间:2019-08-11 21:32:05      阅读:123      评论:0      收藏:0      [点我收藏+]

标签:内容   指针类型   stat   cin   oss   lse   --   res   ati   

第17课 - 继承与多态 - 上

引入:    

如果子类定义了与父类中原型相同的函数会发生什么?

1. 函数重写

在子类中定义与父类中原型相同的函数,函数重写只发生在父类与子类之间。

父类中被重写的函数依然会继承给子类,默认情况下子类中重写的函数将隐藏父类中的函数,通过作用域分辨符::可以访问到父类中被隐藏的函数。

#include <cstdlib>

#include <iostream>

using namespace std;

class Parent

{

public:

    void print()

    {

        cout<<"I‘m Parent..."<<endl;

    }

};

class Child : public Parent

{

public:

    void print()

    {

        cout<<"I‘m Child..."<<endl;

    }

};

int main(int argc, char *argv[])

{

    Child child;

    child.print();

    child.Parent::print();

    cout << "Press the enter key to continue ...";

    cin.get();

    return EXIT_SUCCESS;

}

运行结果:

I‘m Child...

I‘m Parent...

当函数遇到兼容性问题的时候:

#include <cstdlib>

#include <iostream>

using namespace std;

class Parent

{

public:

    void print()

    {

        cout<<"I‘m Parent..."<<endl;

    }

};

class Child : public Parent

{

public:

    void print()

    {

        cout<<"I‘m Child..."<<endl;

    }

};

void howToPrint(Parent* p)

{

    p->print();

}

void run()

{

    Child child;

    Parent* pp = &child;   //赋值兼容性原则,当使用父类的时候都能用子类来代替。

    Parent& rp = child; //Parent类引用,应用Child类对象

    child.print();

    pp->print();  //指针打印

    rp.print();   //引用的打印

}

int main(int argc, char *argv[])

{

    run();

    cout << "Press the enter key to continue ...";

    cin.get();

    return EXIT_SUCCESS;

}

运行结果:

I‘m Child...

I‘m Parent...

I‘m Parent...

分析:

pp执行child,rp引用child。但是后面的两条语句都没有打印I‘m Child...,而是I‘m Parent...。

 

 

l  问题所在:

(1)      C++与C相同,是静态编译型语言。

(2)      在编译时,编译器自动根据指针的类型判断指向的是一个什么样的对象。

(3)      所以编译器认为父类指针指向的是父类对象(根据赋值兼容性原则,这个假设合理)。

(4)      由于程序没有运行,所以不可能知道父类指针指向的具体是父类对象还是子类对象。

(5)      从程序安全的角度,编译器假设父类指针只指向父类对象,因此编译的结果为调用父类的成员函数。

 

对于下面的程序:

void howToPrint(Parent* p)

{

p->print();

}

在编译这个函数的时候,编译器不可能知道指针 p 究竟指向了什么。但是编译器没有理由报错。于是,编译器认为最安全的做法是编译到父类的print函数,因为父类和子类肯定都有相同的print函数。

 

 

2. 程序—函数重写实例(江湖恩怨)

#include <cstdlib>

#include <iostream>

using namespace std;

/*大boss挑战庄主与少庄主*/

class Boss   //大boss

{

private:

    static Boss* cInstance;  //单例模式,就一个 .声明

    Boss()

    {

    }

public:

    static Boss* GetInstance()

    {

        if( cInstance == NULL )

        {

             cInstance = new Boss();

        }   

        return cInstance;

    }

    int fight()

    {

        cout<<"Boss::fight()"<<endl;   //大boss出招

        return 10;

    }

};

Boss* Boss::cInstance = NULL;

//静态变量上面是声明,下面是定义,否则没有意思。

class Master   //庄主

{

public:

    virtual int eightSwordKill() //八剑齐飞

          

    {

        cout<<"Master::eightSwordKill()"<<endl;

        return 8;

    }

};

class NewMaster : public Master //少庄主

{

public:

    virtual int eightSwordKill()

    {

        cout<<"NewMaster::eightSwordKill()"<<endl;

        return Master::eightSwordKill() * 2;

    }

};

void fieldPK(Master* master, Boss* boss)

{

    int k = master->eightSwordKill();

    int b = boss->fight();

    if( k < b )

    {

        cout<<"Master is killed..."<<endl;

    }

    else

    {

        cout<<"Boss is killed..."<<endl;

    }

}

int main(int argc, char *argv[])

{

    Boss* boss = Boss::GetInstance();

    cout<<"Master vs Boss"<<endl;

    Master master;

    fieldPK(&master, boss);

    cout<<"New Master vs Boss"<<endl;

    NewMaster newMaster;

    fieldPK(&newMaster, boss);

    cout << "Press the enter key to continue ...";

    cin.get();

    return EXIT_SUCCESS;

}

 

运行结果:

Master vs Boss

Master::eightSwordKill()

Boss::fight()

Master is killed...

New Master vs Boss

NewMaster::eightSwordKill()

Master::eightSwordKill()

Boss::fight()

Boss is killed...

 

3. 多态的本质

l  面向对象的新需求

根据实际的对象类型来判断重写函数的调用。

如果父类指针指向的是父类对象则调用父类中定义的函数。

如果父类指针指向的是子类对象则调用子类中定义的重写函数。

 

l  面向对象中的多态

根据实际的对象类型决定函数调用语句的具体调用目标。

多态:同样的调用语句有多种不同的表现形态

 

l  C++中的多态支持

C++中通过virtual关键字对多态进行支持。

使用virtual声明的函数被重写后即可展现多态特性。

 

这就是虚函数。虚函数的特点是,不再只是根据指针类型来判定要使用的函数,而是根据指针所指的内容来判断将要引用的函数。

 

小结

函数重写是面向对象中很可能发生的情形。

函数重写只可能发生在父类与子类之间。

需要根据实际对象的类型确定调用的具体函数。

virtual关键字是C++中支持多态的唯一方式。

被重写的虚函数即可表现出多态的特性。

 

C++--第17课 - 继承与多态 - 上

标签:内容   指针类型   stat   cin   oss   lse   --   res   ati   

原文地址:https://www.cnblogs.com/free-1122/p/11336223.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!