精华内容
下载资源
问答
  • C++重载 虚函数 纯虚函数 多态性

    千次阅读 2014-04-18 16:00:41
    C++编程语言是一款应用广泛,支持多种程序设计的计算机编程语言。我们今天就会为大家详细介绍其中C++多态性的一些基本知识,以方便大家在学习过程中对此能够... C++多态性是通过虚函数来实现的,虚函数允许子类重新定

    重载函数:重载可以看作是静态的多态。函数重载的返回类型及所带的参数必须至少有一样不完全相同,只需函数名相同即可。

    虚函数:基类中定义的虚函数在派生类中重新定义时,其函数原型,包括返回类型、函数名、参数个数、参数类型及参数的先后顺序,都必须与基类中的原型完全相同。

    虚函数是一种特殊的重载,即必须被重载的函数(一般函数可以不被重载)。

    重载虚函数时,若与基类中的函数原型出现不同,系统将根据不同情况分别处理:

    1> 仅仅返回类型不同,其余相同,系统会当作出错处理。

    2>函数原型不同,仅仅函数名相同,系统会认为是一般的函数重载,将丢失虚特性。



    C++编程语言是一款应用广泛,支持多种程序设计的计算机编程语言。我们今天就会为大家详细介绍其中C++多态性的一些基本知识,以方便大家在学习过程中对此能够有一个充分的掌握。

      多态性可以简单地概括为“一个接口,多种方法”,程序在运行时才决定调用的函数,它是面向对象编程领域的核心概念。多态(polymorphisn),字面意思多种形状。
      C++多态性是通过虚函数来实现的,虚函数允许子类重新定义成员函数,而子类重新定义父类的做法称为覆盖(override),或者称为重写。(这里我觉得要补充,重写的话可以有两种,直接重写成员函数和重写虚函数,只有重写了虚函数的才能算作是体现了C++多态性)而重载则是允许有多个同名的函数,而这些函数的参数列表不同,允许参数个数不同,参数类型不同,或者两者都不同。编译器会根据这些函数的不同列表,将同名的函数的名称做修饰,从而生成一些不同名称的预处理函数,来实现同名函数调用时的重载问题。但这并没有体现多态性。
      多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用,在编译器编译期间就可以确定函数的调用地址,并生产代码,是静态的,就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定,需要在运行时才确定,这就属于晚绑定。
      那么多态的作用是什么呢,封装可以使得代码模块化,继承可以扩展已存在的代码,他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说,不论传递过来的究竟是那个类的对象,函数都能够通过同一个接口调用到适应各自对象的实现方法。

      最常见的用法就是声明基类的指针,利用该指针指向任意一个子类对象,调用相应的虚函数,可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话,即没有利用C++多态性,则利用基类指针调用相应的函数的时候,将总被限制在基类函数本身,而无法调用到子类中被重写过的函数。因为没有多态性,函数调用的地址将是一定的,而固定的地址将始终调用到同一个函数,这就无法实现一个接口,多种方法的目的了。

    笔试题目:

    [cpp]  view plain copy
    1. #include<iostream>  
    2. using namespace std;  
    3.   
    4. class A  
    5. {  
    6. public:  
    7.     void foo()  
    8.     {  
    9.         printf("1\n");  
    10.     }  
    11.     virtual void fun()  
    12.     {  
    13.         printf("2\n");  
    14.     }  
    15. };  
    16. class B : public A  
    17. {  
    18. public:  
    19.     void foo()  
    20.     {  
    21.         printf("3\n");  
    22.     }  
    23.     void fun()  
    24.     {  
    25.         printf("4\n");  
    26.     }  
    27. };  
    28. int main(void)  
    29. {  
    30.     A a;  
    31.     B b;  
    32.     A *p = &a;  
    33.     p->foo();  
    34.     p->fun();  
    35.     p = &b;  
    36.     p->foo();  
    37.     p->fun();  
    38.     return 0;  
    39. }  
           第一个p->foo()和p->fuu()都很好理解,本身是基类指针,指向的又是基类对象,调用的都是基类本身的函数,因此输出结果就是1、2。
        第二个输出结果就是1、4。p->foo()和p->fuu()则是基类指针指向子类对象,正式体现多态的用法,p->foo()由于指针是个基类指针,指向是一个固定偏移量的函数,因此此时指向的就只能是基类的foo()函数的代码了,因此输出的结果还是1。而p->fun()指针是基类指针,指向的fun是一个虚函数,由于每个虚函数都有一个虚函数列表,此时p调用fun()并不是直接调用函数,而是通过虚函数列表找到相应的函数的地址,因此根据指向的对象不同,函数地址也将不同,这里将找到对应的子类的fun()函数的地址,因此输出的结果也会是子类的结果4。
      笔试的题目中还有一个另类测试方法。即

           B *ptr = (B *)&a;  ptr->foo();  ptr->fun();
      问这两调用的输出结果。这是一个用子类的指针去指向一个强制转换为子类地址的基类对象。结果,这两句调用的输出结果是3,2。
      并不是很理解这种用法,从原理上来解释,由于B是子类指针,虽然被赋予了基类对象地址,但是ptr->foo()在调用的时候,由于地址偏移量固定,偏移量是子类对象的偏移量,于是即使在指向了一个基类对象的情况下,还是调用到了子类的函数,虽然可能从始到终都没有子类对象的实例化出现。
      而ptr->fun()的调用,可能还是因为C++多态性的原因,由于指向的是一个基类对象,通过虚函数列表的引用,找到了基类中fun()函数的地址,因此调用了基类的函数。由此可见多态性的强大,可以适应各种变化,不论指针是基类的还是子类的,都能找到正确的实现方法。
    [cpp]  view plain copy
    1. //小结:1、有virtual才可能发生多态现象  
    2. // 2、不发生多态(无virtual)调用就按原类型调用  
    3. #include<iostream>  
    4. using namespace std;  
    5.   
    6. class Base  
    7. {  
    8. public:  
    9.     virtual void f(float x)  
    10.     {  
    11.         cout<<"Base::f(float)"<< x <<endl;  
    12.     }  
    13.     void g(float x)  
    14.     {  
    15.         cout<<"Base::g(float)"<< x <<endl;  
    16.     }  
    17.     void h(float x)  
    18.     {  
    19.         cout<<"Base::h(float)"<< x <<endl;  
    20.     }  
    21. };  
    22. class Derived : public Base  
    23. {  
    24. public:  
    25.     virtual void f(float x)  
    26.     {  
    27.         cout<<"Derived::f(float)"<< x <<endl;   //多态、覆盖  
    28.     }  
    29.     void g(int x)  
    30.     {  
    31.         cout<<"Derived::g(int)"<< x <<endl;     //隐藏  
    32.     }  
    33.     void h(float x)  
    34.     {  
    35.         cout<<"Derived::h(float)"<< x <<endl;   //隐藏  
    36.     }  
    37. };  
    38. int main(void)  
    39. {  
    40.     Derived d;  
    41.     Base *pb = &d;  
    42.     Derived *pd = &d;  
    43.     // Good : behavior depends solely on type of the object  
    44.     pb->f(3.14f);   // Derived::f(float) 3.14  
    45.     pd->f(3.14f);   // Derived::f(float) 3.14  
    46.   
    47.     // Bad : behavior depends on type of the pointer  
    48.     pb->g(3.14f);   // Base::g(float)  3.14  
    49.     pd->g(3.14f);   // Derived::g(int) 3   
    50.   
    51.     // Bad : behavior depends on type of the pointer  
    52.     pb->h(3.14f);   // Base::h(float) 3.14  
    53.     pd->h(3.14f);   // Derived::h(float) 3.14  
    54.     return 0;  
    55. }  
    令人迷惑的隐藏规则
    本来仅仅区别重载与覆盖并不算困难,但是C++的隐藏规则使问题复杂性陡然增加。
    这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数,规则如下:
    (1)如果派生类的函数与基类的函数同名,但是参数不同。此时,不论有无virtual
    关键字,基类的函数将被隐藏(注意别与重载混淆)。
    (2)如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有virtual
    关键字。此时,基类的函数被隐藏(注意别与覆盖混淆)。
    上面的程序中:
    (1)函数Derived::f(float)覆盖了Base::f(float)。
    (2)函数Derived::g(int)隐藏了Base::g(float),而不是重载。
    (3)函数Derived::h(float)隐藏了Base::h(float),而不是覆盖。


    C++纯虚函数
     一、定义
      纯虚函数是在基类中声明的虚函数,它在基类中没有定义,但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0” 
      virtual void funtion()=0 
    二、引入原因
       1、为了方便使用多态特性,我们常常需要在基类中定义虚拟函数。 
       2、在很多情况下,基类本身生成对象是不合情理的。例如,动物作为一个基类可以派生出老虎、孔雀等子类,但动物本身生成对象明显不合常理。 
      为了解决上述问题,引入了纯虚函数的概念,将函数定义为纯虚函数(方法:virtual ReturnType Function()= 0;),则编译器要求在派生类中必须予以重写以实现多态性。同时含有纯虚拟函数的类称为抽象类,它不能生成对象。这样就很好地解决了上述两个问题。
    三、相似概念
       1、多态性 
      指相同对象收到不同消息或不同对象收到相同消息时产生不同的实现动作。C++支持两种多态性:编译时多态性,运行时多态性。 
      a、编译时多态性:通过重载函数实现 
      b、运行时多态性:通过虚函数实现。 

      2、虚函数 
      虚函数是在基类中被声明为virtual,并在派生类中重新定义的成员函数,可实现成员函数的动态覆盖(Override)
      3、抽象类 
      包含纯虚函数的类称为抽象类。由于抽象类包含了没有定义的纯虚函数,所以不能定义抽象类的对象

    展开全文
  • 一:多态性 在这里插入代码片 二:纯虚函数 #include "pch.h" #include <iostream> using namespace std; class human { public: void fun() { } virtual void eat() = 0; //虚函数声明后面加上=0就成为了...

    一:多态性

    从代码实现上,如果调用虚函数走的流程是虚函数表,那么就是多态。
    

    二:纯虚函数

    #include "pch.h"
    #include <iostream>
    using namespace std;
    
    class human
    {
    public:
    	void fun() { }
    	virtual void eat() = 0; //虚函数声明后面加上=0就成为了一个纯虚函数
    	/*纯虚函数,没有函数实体,
    	因为有纯虚函数的存在,所以human类成了一个
    	抽象类,纯虚函数,也就是说在基类中,只给出函数的声明,而具体的
    	函数实现部分交给子类去做。
    	*/
    };
    
    class man :public human
    {
    public:
    	void eat() { cout << "面食" << endl; };
    };
    
    class woman :public human
    {
    public:
    	void eat() { cout << "米饭" << endl; }; //错误
    };
    int main()
    {
    	//human phuman; //因为是一个抽象类,所以不能定义对象。
    	
    	return 0;
    }
    

    三:虚析构(基类的析构函数一般写成虚函数)

    #include "pch.h"
    #include <iostream>
    using namespace std;
    
    class human
    {
    public:
    	void fun() { }
    	virtual void eat() { } 
    
    	human()
    	{
    		cout << "human()" << endl;
    	}
    
    	 ~human()
    	{
    		cout << "~human()" << endl;
    	}
    };
    
    class man :public human
    {
    public:
    	void eat() { cout << "面食" << endl; };
    
    	man()
    	{
    		cout << "man()" << endl;
    	}
    
    	~man()
    	{
    		cout << "~man()" << endl;
    	}
    };
    
    class woman :public human
    {
    public:
    	void eat() { cout << "米饭" << endl; }; 
    
    	woman()
    	{
    		cout << "woman()" << endl;
    	}
    	~woman()
    	{
    		cout << "~woman()" << endl;
    	}
    };
    int main()
    {
    	human *phuman = new man; 
    	delete phuman; //并没有调用man的析构函数,会造成内存泄漏,
    	/*那怎么办?可以把基类的析构函数写成虚析构函数就可以了,
    	virtual ~human()
    	{
    		cout << "~human()" << endl;
    	}*/
    
    	//即使父类和子类的析构函数不同名,但是虚函数的性质还是会影响到子类当中,即动态绑定。
    	return 0;
    }
    

    可参考:https://blog.csdn.net/Hackbuteer1/article/details/7558868

    展开全文
  • c++知识细节-基类指针指向子类对象/虚纯虚函数/多态性/虚析构 基类指针,派生类指针 新玩法: 父类指针可以new一个子类对象. Human *phuman = new Men; phuman->funchuman(); //父类类型指针可以调用父类的成员函数...

    c++知识细节-基类指针指向子类对象/虚纯虚函数/多态性/虚析构

    基类指针,派生类指针

    新玩法: 父类指针可以new一个子类对象.

    Human *phuman = new Men;
    phuman->funchuman();	//父类类型指针可以调用父类的成员函数
    phuman->funcmen();	//不可以,因为你是一个父类指针
    

    Q: 既然父类指针没有办法调用子类的成员函数,那么为什么还让父类指针指向子类对象呢?

    虚函数

    Q: 有没有一个解决方法,使我们只定义一个对象指针,就能调用各种子类对象的成员函数?
    A: 调用父子类中的同名同参函数的话,对这个函数是有要求的.在父类的eat()函数声明之前必须加virtual关键字,将其声明为虚函数.函数实现不用加.子类中可加可不加,因为一旦某个函数被声明成了虚函数,那么所有子类中它都是虚函数.加上有助于阅读.

    Human *phuman = new Men;
    phuman->eat();	//此时调用的是父类的eat()函数->"人类吃各种粮食"
    ===============================================================
    //父类eat()声明前加上virtual后
    phuman->eat();	//此时调用的是Men类的eat()函数->"男人喜欢吃米饭"
    phuman->Human::eat();	//这样写可以调用Human类的eat()函数
    delete phuman;
    phuman = new Women;
    phuman->eat();	//此时调用的是Women类的eat()函数->"女人喜欢吃面食"
    

    Notes:
    ①为了避免在子类中写错虚函数(比如参数或参数个数写的和父类不同了),在子类中的函数声明后可以添加override关键字,此时写错时编译器会提示报错.override关键字就是用来修饰子类中的虚函数的.
    ②final也是虚函数专用,他是用在父类中.如果在父类的函数声明中加了final,那么任何尝试覆盖该函数的操作都会报错.
    ③子类中的虚函数必须和父类中声明的一致.
    ④调用虚函数时执行的是动态绑定.动态:程序运行的时候才知道调用了哪个子类的eat()虚函数,取决于你new的是什么子类的对象.

    多态性

    多态性就是针对虚函数来说的.
    多态性: 体现在具有继承关系的父类和子类之间.通过父类指针,在程序运行时期,找到动态绑定到父类指针上的对象,这个对象既可能是父类对象也可能是子类对象,然后系统内部通过查虚函数表,找到函数eat()的入口地址,从而调用父类或者子类的eat()函数,这就是运行时期的多态性.

    纯虚函数

    (1)纯虚函数是在基类中声明的虚函数,但他在基类中没有定义.但是要求所有派生类中都要定义这个虚函数的实现方法.
    (2)基类中纯虚函数的实现是在纯虚函数的定义后面加上 =0.
    (3)一旦在一个类中定义了纯虚函数,那么就不能生成这个类的对象了.这个类就成了抽象类了,不能用来生成对象了.
    抽象类的作用就是用来统一管理子类对象.

    virtual void eat2() = 0;
    

    基类的析构函数要写成虚函数

    Human* phuman = new Men;
    delete phoman;	//没有执行子类的析构函数,坏事
    

    结论: 用基类指摘new子类的对象,在delete的时候系统不会调用子类的构造函数.
    Q: 如何解决?
    A: 把父类的析构函数写成虚函数.
    Notes:
    ①在public继承中,基类对派生类及其对象的操作,只能影响到从基类继承下来的成员.
    ②如果想要用基类对非继承成员进行操作,则要把基类的这个函数定义为虚函数,析构函数自然也应该如此.
    ③此时基类中析构函数的虚属性也会继承给子类,这样的话子类中的析构函数也就自然而然成了虚函数,虽然名字和基类的析构函数名字不同.
    ④ delete phuman时,为了调用子类Men的析构函数,则调用的函数必须是virtual的,也就是为了获得运行时的多态行为.
    ⑤虚析构的函数保证析构是一定会从子类开始析构。
    子类析构时,会依次调用子类析构函数(~men),类成员变量析构函数,基类析构函数(~Human)。

    代码类

    //声明基类Human.h
    #include <iostream>
    class Human
    {
    public:
    	Human();
    	Human(int);
    public:
    	int m_age;	//年龄
    	char m_name[100];	//姓名
    	void funchuman(){}
    public:
    	virtual void eat();
    };	//类定义时千万不要忘记分号
    
    //定义基类Human.cpp
    #include <iostream>
    #include "Human.h"
    Human::Human()
    {
    	cout << "执行了Human::Human()" << endl;
    }
    Human::Human(int abc)
    {
    	cout << "执行了Human::Human(int)" << endl;
    }
    void Human::eat()
    {
    	std::cout << "人类吃各种粮食" << std::endl;
    }
    
    //声明子类Men.h
    #include <iostream>
    #include "Human.h"
    class Men : public Human	//表示Men是Human的子类
    {
    public:
    	Men();
    	void funcmen(){}
    public:
    	void eat();
    };	//类定义时千万不要忘记分号
    
    //定义子类Men.cpp
    #include <iostream>
    #include "Men.h"
    Men::Men()
    {
    	cout << "执行了Men::Men()" << endl;
    }
    void Men::eat()
    {
    	std::cout << "男人喜欢吃米饭" << std::endl;
    }
    
    //声明子类Women.h
    #include <iostream>
    #include "Human.h"
    class Women : public Human	//表示Men是Human的子类
    {
    public:
    	Women();
    	void funcwomen(){}
    public:
    	void eat();
    };	//类定义时千万不要忘记分号
    
    //定义子类Women.cpp
    #include <iostream>
    #include "Women.h"
    Women::Women()
    {
    	cout << "执行了Women::Women()" << endl;
    }
    void Women::eat()
    {
    	std::cout << "女人喜欢吃面食" << std::endl;
    }
    
    展开全文
  • 由于虚函数的出现,导致基类指针根据不同的对象会调用不同的虚函数,这里成为运行时的动态绑定,只有运行中才能知道该调用哪个,也是动态多态性。静态多态性指的是函数的重载,这在编译过程中就知道该调用哪个,...
    class human
    {
        public:
        human();
        ~human();
        void func();
    };
    
    class man:public man
    {
        public:
        man();
        ~man();
        void func();
    };

    申请内存时,可以使基类指针指向其派生类的对象。

    human *h = new human;

    human *h = new man;

    以上都是可以的。但是此指针只能调用基类被继承的成员。如果基类和子类都有一个同名函数,那么h->func()调用的无论如何都是基类的func。如果想要在指针指向man对象时调用man的func呢,这时则需要虚函数了

    class human
    {
        public:
        human();
        ~human();
        virtual void func();
    };
    
    class man:public man
    {
        public:
        man();
        ~man();
        virtual void func();
    };

    当基类中的同名函数设置为virtual时,子类中无论加不加virtual都会自动变成虚函数,当然最好习惯性的加上,便于阅读。

    这时基类指针指向基类对象就调用的基类的func,指向子类的对象,调用的就是子类的func。

    如果在子类的同名函数后加上override后,如果此函数声明的和基类中不一样,就会报错。

    如果在基类的同名函数后加上final后,如果子类有同名函数想要覆盖此函数,则会报错。

     纯虚函数:如果基类中同名函数只有声明没有定义,只有子类中有相应的定义,则次函数为纯虚函数,同时基类也成了抽象类,无法实例化。

    class human
    {
        public:
        human();
        ~human();
        virtual void func() = 0;
    };
    
    class man:public man
    {
        public:
        man();
        ~man();
        virtual void func();
    };

     由于虚函数的出现,导致基类指针根据不同的对象会调用不同的虚函数,这里成为运行时的动态绑定,只有运行中才能知道该调用哪个,也是动态多态性。静态多态性指的是函数的重载,这在编译过程中就知道该调用哪个,静态绑定。

     

    基类的析构函数一定要定义成虚函数,因为如果不是虚函数,当用指针开辟了指向子类对象的空间时,当delete时,只会调用基类的析构函数,子类的析构函数无法调用。会导致子类中申请空间的变量的空间无法释放,从而内存泄漏

    展开全文
  • 1、纯虚函数(pure virtual)纯虚函数的定义形式:virtual { } = 0;纯虚函数就是基类只声明函数体,没有实现过程。时对子类的约束,是接口继承。2、虚函数(Impure virtual)虚函数的定义形式:virtual {method...
  • 发现基类中xx函数是虚函数C++就采用迟绑定技术,也就是说编译时并不确定具体调用哪个函数,而是在运行时根据对象为类型来确定调用哪一个函数---------------这就叫C++的多态性 多态性 纯虚函数
  • 多态性,虚函数与纯虚函数(复习干货) 向对象发送同一个消息,不同的对象在接收时会产生不同的 行为(即方法,属于本对象的行为)。 多态分为静态多态性和动态多态性。 静态多态性,函数重载和运算符重载都...
  • C++支持两种多态性:编译时多态性,运行时多态性 编译时多态性:通过重载函数实现。运行时多态性:通过虚函数实现 在C++中,我们可以把只能用于被继承而不能直接创建对象的类设置为抽象类( Abstract Class) 我们...
  • C++支持两种多态性:编译时多态性,运行时多态性。 1.编译时多态性:通过重载函数实现; 2.运行时多态性:通过虚函数实现。 二、虚函数函数是在基类中被声明为virtual,并在派生类中重新定义的成员函数。可实现...
  • 什么是纯虚函数 纯虚函数的作用 如何定义使用纯虚函数   一 定义: 纯虚函数是一种特殊的虚函数,它的一般格式如下:   class <类名>   {   virtual <类型><函数名>(&...
  • 多态性(Polymorphism)  指一个名字,多种语义;  一个接口,多种方法 • 所谓多态性是指当不同的对象收到相同的消息时,  产生不同的动作。... 在程序运行时的多态性通过继承和虚函数来体
  • 第一次写博客记录自己学习c++中纯虚函数、类的组合及多态性知识总结。 纯虚函数:声明形式为: virtual 函数类型 函数名(函数形参表)=0; 含有纯虚函数的类是抽象类,抽象类不能实例化,需要由其派生类具体给出纯虚...
  • 1、虚函数:虚函数可以实现函数的覆盖,使得派生类中的函数得以实现,提高了程序的可扩充,另外,基类是虚函数,派生类同名函数也会变成虚函数。指向基类的指针在指 向派生类对象时可以调用派生类。 2、虚析构...
  • C++中的多态性纯虚函数

    千次阅读 2013-05-30 11:07:00
    C++的多态性:  当C++中在继承时会发生函数覆盖(覆盖的概念我的上一篇blog),此时如果将子类对象的地址赋给父类对象的指针,用该指针调用函数时,当子类中有这样的函数,则调用子类的函数,如果没有,则调用父类的...
  • 1、程序功能:设计一个基类...使用抽象类Shapes类型的指针(或引用),当它指向(或引用)某个派生类的对象时,就可以通过它访问该对象的虚成员函数display()实现动态多态性。 2、程序功能:利用抽象类和纯虚函数...
  • 1 虚函数与多态性 ...这节我们学习c++中的虚函数与多态性、和纯虚函数,先来看一个例子: #include using namespace std; class animal{ public : void eat(){ cout ; } void sleep(){ cout ;
  • 其实这些也可以通过在基类中定义虚函数来实现,但抽象类跟一般类不同的是,它使用纯虚函数,不需要定义纯虚函数的实现,而且抽象类不能实例化,即不能定义抽象类的对象,只能从它继承出非抽象派生类再实例化。...
  • 多态性、虚函数、纯虚函数和抽象类知识网络构造 请针对多态性、虚函数、纯虚函数和抽象类几个重要知识点,给出你的理解和分析,尽可能条理清晰、全面,分层次、逐条列出。 友情提醒:不要摘抄或者抄袭,用自己的语言...
  • 一:虚函数 1.用virtual关键字声明的函数叫虚函数  虚函数标明在基类声明的虚函数是虚拟的,并不是实际存在的函数,在派生类中才会正式定义此函数  虚函数的作用是允许在派生类中重新定义与基类同名的函数,...
  • 2.2.7 虚函数与多态性纯虚函数1.虚函数与多态性因为鱼的呼吸是吐泡泡,和一般动物的呼吸不太一样,所以我们在fish类中重新定义breathe方法。我们希望如果对象是鱼,就调用fish类的breathe()方法,如果对象是动物...
  • c++多态性纯虚函数

    2015-04-09 20:54:38
     多态性作用于基类和子类之间,如果基类的函数加了virtual称为虚函数,则对象调用的函数则是他自己的函数(就是子类则调用它自己的函数,不会调用基类同名的虚函数)。反之如果基类和子类之间同时存在同名函数,则...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,609
精华内容 3,843
关键字:

纯虚函数多态性