精华内容
下载资源
问答
  • 如果类中至少有一个函数被声明为纯虚函数,则这个类就是抽象类纯虚函数是通过在声明中使用 “= 0” 来指定的 如 virtual int fun()=0; 定义一个函数为虚函数,不代表函数为不被实现的函数。 定义他为虚函数是为了...

    C++ 接口是使用抽象类来实现的,抽象类与数据抽象互不混淆,数据抽象是一个把实现细节与相关的数据分离开的概念。

    如果类中至少有一个函数被声明为纯虚函数,则这个类就是抽象类。纯虚函数是通过在声明中使用 “= 0” 来指定的

    如 virtual int fun()=0;


    定义一个函数为虚函数,不代表函数为不被实现的函数。

    定义他为虚函数是为了允许用基类的指针来调用子类的这个函数。

    定义一个函数为纯虚函数,才代表函数没有被实现。

    定义纯虚函数是为了实现一个接口,起到一个规范的作用,规范继承这个类的程序员必须实现这个函数。带纯虚函数的类叫虚基类,这种基类不能直接生成对象,而只有被继承,并重写其虚函数后,才能使用。


    #include "stdafx.h"
    #include<iostream>
    using namespace std;
    // 基类
    class Shape
    {
    public:
    // 提供接口框架的纯虚函数
    virtual int getArea() = 0;
    void setWidth(int w)
    {
        width = w;
    }
    void setHeight(int h)
    {
        height = h;
    }
    protected:
    int width;
    int height;
    };
    
    // 派生类
    class Rectangle : public Shape
    {
    public:
    int getArea()
    {
        return (width * height);
    }
    };
    class Triangle : public Shape
    {
    public:
    int getArea()
    {
        return (width * height) / 2;
    }
    };
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    Rectangle rec;
    Triangle tri;
    rec.setHeight(10);
    rec.setWidth(10);
    
    tri.setHeight(10);
    tri.setWidth(10);
    
    cout << "rectangle area:" << rec.getArea() << endl;
    cout << "rectangle area:" << tri.getArea() << endl;
    
    
    
    system("pause");
    return 0;
    }
    

    rectangle area:100
    rectangle area:50


    展开全文
  • abstract class是抽象类至少包含一个纯虚函数的类就叫做抽象类。 但是如果一个类,所有的成员都是纯虚函数,那么它和一般的抽象类在用法上是区别的。至少Microsoft给的COM接口定义全部都是仅由纯虚函数构成的...

    abstract class是抽象类,至少包含一个纯虚函数的类就叫做抽象类。

    但是如果一个类,所有的成员都是纯虚函数,那么它和一般的抽象类在用法上是有区别的。至少Microsoft给的COM接口定义全部都是仅由纯虚函数构成的类。因此把这样的类定义叫做纯虚类也不算错。

    纯虚函数和虚函数的区别在于前者不包含定义,而后者包含函数体。

    那么纯虚类就是不包含任何实现(包括成员函数定义和成员变量定义。前者代表算法,后者代表结构)不包含任何算法和结构的类叫做纯虚类,应该没有问题。


    justforfun626说我confused with the name of abstract class,那是因为在Java里面的确没有纯虚类的概念,因为Java里没有纯虚函数这个概念。Java管虚函数叫做abstract function,管抽象类叫做abstract class,直接说来,Java根本没有virtual这个关键字,都用abstract代替,因此Java里面根本就没有Pure这个概念。有那就是interface。在interface里面定义的函数都不能有函数体,这个在Java里面叫做接口。那么C++里面与interface等同的概念就是纯虚类了,C++用纯虚类来模拟interface这个抽象概念,因此这里说的“纯虚类”与Java的abstract class不同,与C++的一般抽象类也不同。“纯虚类”与C++一般抽象类的区别就好比Java里面interface 和 abstract class的区别。

    ----------------------------------

    //今天深刻理解了虚函数和纯虚函数的作用和用法
    //如果子类实现了虚函数则调用子类的方法,
    //如果子类没有实现该函数则调用父类的方法。
    //究竟怎么用呢:
    假如CChild 派生自 CMan ,有个虚函数 Eat();
    
    CMan m_man;
    CChild m_child;
    //这才是使用的精髓,如果不定义基类的指针去使用,没有太大的意义
    CMan *p ;
    p = &m_man ; 
    p->Eat(); //始终调用CMan的Eat成员函数,不会调用 CChild 的
    p = &m_child;
    p->Eat(); //如果子类实现了该方法,则始终调用CChild的Eat函数
    //不会调用CMan 的 Eat 方法 如果子类没有实现该函数
    //则调用CMan的Eat函数
    //呵呵,就这些了,还得用心体会
    //纯虚函数就是基类只定义了函数体,没有实现过程 定义方法如下
    // virtual void Eat() = 0; 直接=0 不要 在cpp中定义就可以了
    //纯虚函数相当于接口,不能直接实例话,需要派生类来实现函数定义
    //有的人可能在想,定义这些有什么用啊 ,我觉得很有用
    //比如 你想描述一些事物的属性给别人,而自己不想去实现,就可以定
    //义为纯虚函数。说的再透彻一些。比如盖楼房,你是老板,你给建筑公司
    //描述清楚你的楼房的特性,多少层,楼顶要有个花园什么的
    //建筑公司就可以按照你的方法去实现了,如果你不说清楚这些,可能建筑
    //公司不太了解你需要楼房的特性。用纯需函数就可以很好的分工合作了
    //你觉得有道理吗?


    ---------------------------------

    2、抽象类:

    抽象类是一种特殊的类,它是为了抽象和设计的目的为建立的,它处于继承层次结构的较上层。

    ⑴抽象类的定义:

    称带有纯虚函数的类为抽象类

    ⑵抽象类的作用:

    抽象类的主要作用是将有关的操作作为结果接口组织在一个继承层次结构中,由它来为派生类提供一个公共的根,派生类将具体实现在其基类中作为接口的操作。所以派生类实际上刻画了一组子类的操作接口的通用语义,这些语义也传给子类,子类可以具体实现这些语义,也可以再将这些语义传给自己的子类。

    (3)使用抽象类时注意:

    •   抽象类只能作为基类来使用,其纯虚函数的实现由派生类给出如果派生类中没有重新定义纯虚函数,而只是继承基类的纯虚函数,则这个派生类仍然还是一个抽象类如果派生类中给出了基类纯虚函数的实现,则该派生类就不再是抽象类了,它是一个可以建立对象的具体的类

    •   抽象类是不能定义对象的。

    ---------------------------------------------

    (原名)我对C++中虚函数、纯虚函数在实现多态中作用的一点浅薄认识 

    mahongxi(原作) 


    多态是面向对象程序设计和面向过程程序设计的主要区别之一,何谓多态?记得在CSDN里一篇论C++多态的文章里有一名话:“龙生九子,子子不同”多态就是同一个处理手段可以用来处理多种不同的情况,在钱能老师的《C++程序设计教程》书中有这样一个例子:
    定义了一个小学生类
    [本文全部代码均用伪码]
    class Student
    {public:
    Student(){}
    ~Student(){}
    void 交学费(){}
    //......
    };
    里面有一个 “交学费”的处理函数,因为大学生和小学生一些情况类似,我们从小学生类中派生出大学生类:
    class AcadStudent:public Student
    {public:
    AcadStudent(){}
    ~ AcadStudent(){}
    void 交学费(){}

    //.......
    };

    我们知道,中学生交费和大学生交费情况是不同的,所以虽然我们在大学生中继承了中学生的"交学费"操作,但我们不用,把它重载,定义大学生自己的交学费操作,这样当我们定义了一个小学生,一个大学生后:

    Student A;
    AcadStudent B;

    A.交学费(); 即调用小学生的,B.交学费();是调用大学生的,功能是实现了,但是你要意识到,可能情况不仅这两种,可能N种如:小学生、初中生、高中生、研究生.....
    它们都可以以Student[小学生类]为基类。

    如果系统要求你在一群这样的学生中,随便抽出一位交纳学费,你怎么做?

    :
    //A为抽出来的要交学费的同学 
    {switch(typeof(A))
    {case 小学生:A.小学生:: 交学费 ();break;
    case 初中生:A.初学生:: 交学费 ();break;
    case 高中生:A.高学生:: 交学费 ();break;

    default: 
    ............. 

    }

    首先,我们要在每个类中定义一个 typeof()用来识别它的类型,然后还要在程序中进行区别,这样一来,虽然也行,但是,如果再增加类型则要改动switch,又走了面向过程的老路,而且想通过一个模块进行操作实现起来也有难度。
    所以C++中提供了多态,即能通过迟后联编的技术实现动态的区分。
    在基类的"交学费"前加个Virtual 用来告诉系统,遇到这个处理过程要等到执行时再确定到底调用哪个类的处理过程。这样一来就可以:

    void 通用的交学费操作 (Student &A)
    {A.交学费();
    }

    一下全部搞定,你再加新的类型我也不怕!!![具体的实现原理参考:《Inside The C++ Object Model》]。如果没有 virtual这一声明,那么,系统在执行前就确定了操作,比如把“大学生”传给 
    void 通用的交学费操作 (Student &A)
    {A.交学费();
    }
    ,则A.交学费();调用的是大学生类中继承于Student类中的“交学费操作”
    所以虚函数对多态的实现是必要的。

    为什么会出现纯虚函数呢?

    如果按上面的例子进行编程,所有类型都继承小学生类,我们会发现一此小学生自己特定的东东[比如 void 上美术课();],也都被大学生继承来了,虽然不影响大学生的操作,但是随时间的加长,小学生类中自已所特定的东东越来越多,这样下去,大学生中冗余的数据就多了,有什么办法可以解决????

    就是定义基类时定义一个抽象类,如学生类,在学生类中实现一此大家都有的操作
    。这个过程就叫分解。
    这个类子对纯虚函数的说明还不够明显,换个例子比如:



    class 人()
    {public :
    //......
    void 吃()
    {人吃饭;
    }
    //......
    char *Name;
    int age;
    };

    class 狗()
    {public :
    //......
    void 吃()
    {狗吃屎;
    }
    //......
    char *Name;
    int age;
    };
    人类、狗类有一些相同的东东,如名字,年纪,吃的动作等,有人想到了为了代码的重用,让人类继承狗类,可是数据的冗余让这个想法完蛋了,所以有人又想出可不可以定义一个这样的类:


    这个类界于人类狗类之间,有人类和狗类共有的一些东东,比如年纪,名字,体重什么的,但它是不存在实例的,它的存在意义也是只是为了派生其它类,如人类、狗类,这样可以使系统清淅、。。。。。、、反正好处多多。

    在这个世界上根本不存在界于人狗之间的东东,所以这个“人狗之间类”中的“吃”也是没什么意义,你也很难为它的内容下个定义,况且也没必要,所以定义它为纯虚函数,形式为:virtual void 吃()=0; 用来告诉系统:
    1、这个函数可以没有函数定义;
    2、拥有本函数的类是抽象类;
    你可能会说,即然纯虚函数没什么意义,为什么还要它,它的作用是什么呢?
    为实现多态作准备!!!

    由于抽象类的实例没意义,所以C++中不允许定义它的实例。(如果定义了这样的实例A,那么你调用A.吃()怎么办?)


    当然了,你也可以在基类中,virtual 吃(){}
    这样一来,基类就不是抽象类了,可以有实例,而且对于其它方面都不影响。

    但你也要承认这样的对象是没有什么意识的,它的存在只能使你思考上增加负担,除错时还要考虑到是不是有这样类的对象在作怪,所以C++干脆提供了“虚函数”、抽象类,的机制,给我们操作时加了限制也可以认为是保险[不可以有抽象类的对象],试想当代码变得非常之庞大时,它的存在是多么有必要啊.

    展开全文
  • 但是如果一个类,所有的成员都是纯虚函数,那么它和一般的抽象类在用法上是区别的。至少Microsoft给的COM接口定义全部都是仅由纯虚函数构成的类。因此把这样的类定义叫做纯虚类也不算错。纯虚函数和虚函数的区别...

    abstract class是抽象类,至少包含一个纯虚函数的类就叫做抽象类。

    但是如果一个类,所有的成员都是纯虚函数,那么它和一般的抽象类在用法上是有区别的。至少Microsoft给的COM接口定义全部都是仅由纯虚函数构成的类。因此把这样的类定义叫做纯虚类也不算错。

    纯虚函数和虚函数的区别在于前者不包含定义,而后者包含函数体。

    那么纯虚类就是不包含任何实现(包括成员函数定义和成员变量定义。前者代表算法,后者代表结构)。不包含任何算法和结构的类叫做纯虚类,应该没有问题。


    justforfun626说我confused with the name of abstract class,那是因为在Java里面的确没有纯虚类的概念,因为Java里没有纯虚函数这个概念。Java管虚函数叫做abstract function,管抽象类叫做abstract class,直接说来,Java根本没有virtual这个关键字,都用abstract代替,因此Java里面根本就没有Pure这个概念。有那就是interface。在interface里面定义的函数都不能有函数体,这个在Java里面叫做接口。那么C++里面与interface等同的概念就是纯虚类了,C++用纯虚类来模拟interface这个抽象概念,因此这里说的“纯虚类”与Java的abstract class不同,与C++的一般抽象类也不同。“纯虚类”与C++一般抽象类的区别就好比Java里面interface 和 abstract class的区别。

    ----------------------------------

    //今天深刻理解了虚函数和纯虚函数的作用和用法
    //如果子类实现了虚函数则调用子类的方法,
    //如果子类没有实现该函数则调用父类的方法。
    //究竟怎么用呢:
    假如CChild 派生自 CMan ,有个虚函数 Eat();

    CMan m_man;
    CChild m_child;
    //这才是使用的精髓,如果不定义基类的指针去使用,没有太大的意义
    CMan *p ;
    p = &m_man ;
    p->Eat(); //始终调用CMan的Eat成员函数,不会调用 CChild 的
    p = &m_child;
    p->Eat(); //如果子类实现了该方法,则始终调用CChild的Eat函数
    //不会调用CMan 的 Eat 方法 如果子类没有实现该函数
    //则调用CMan的Eat函数
    //呵呵,就这些了,还得用心体会
    //纯虚函数就是基类只定义了函数体,没有实现过程 定义方法如下
    // virtual void Eat() = 0; 直接=0 不要 在cpp中定义就可以了
    //纯虚函数相当于接口,不能直接实例话,需要派生类来实现函数定义
    //有的人可能在想,定义这些有什么用啊 ,我觉得很有用
    //比如 你想描述一些事物的属性给别人,而自己不想去实现,就可以定
    //义为纯虚函数。说的再透彻一些。比如盖楼房,你是老板,你给建筑公司
    //描述清楚你的楼房的特性,多少层,楼顶要有个花园什么的
    //建筑公司就可以按照你的方法去实现了,如果你不说清楚这些,可能建筑
    //公司不太了解你需要楼房的特性。用纯需函数就可以很好的分工合作了
    //你觉得有道理吗?

    ---------------------------------

    2、抽象类:

    抽象类是一种特殊的类,它是为了抽象和设计的目的为建立的,它处于继承层次结构的较上层。

    ⑴抽象类的定义:

    称带有纯虚函数的类为抽象类。

    ⑵抽象类的作用:

    抽象类的主要作用是将有关的操作作为结果接口组织在一个继承层次结构中,由它来为派生类提供一个公共的根,派生类将具体实现在其基类中作为接口的操作。所以派生类实际上刻画了一组子类的操作接口的通用语义,这些语义也传给子类,子类可以具体实现这些语义,也可以再将这些语义传给自己的子类。

    (3)使用抽象类时注意:

    •   抽象类只能作为基类来使用,其纯虚函数的实现由派生类给出。如果派生类中没有重新定义纯虚函数,而只是继承基类的纯虚函数,则这个派生类仍然还是一个抽象类。如果派生类中给出了基类纯虚函数的实现,则该派生类就不再是抽象类了,它是一个可以建立对象的具体的类。

    •   抽象类是不能定义对象的。

    ---------------------------------------------

    (原名)我对C++中虚函数、纯虚函数在实现多态中作用的一点浅薄认识

    mahongxi(原作)


    多态是面向对象程序设计和面向过程程序设计的主要区别之一,何谓多态?记得在CSDN里一篇论C++多态的文章里有一名话:“龙生九子,子子不同”多态就是同一个处理手段可以用来处理多种不同的情况,在钱能老师的《C++程序设计教程》书中有这样一个例子:
    定义了一个小学生类
    [本文全部代码均用伪码]
    class Student
    {public:
    Student(){}
    ~Student(){}
    void 交学费(){}
    //......
    };
    里面有一个 “交学费”的处理函数,因为大学生和小学生一些情况类似,我们从小学生类中派生出大学生类:
    class AcadStudent:public Student
    {public:
    AcadStudent(){}
    ~ AcadStudent(){}
    void 交学费(){}

    //.......
    };

    我们知道,中学生交费和大学生交费情况是不同的,所以虽然我们在大学生中继承了中学生的"交学费"操作,但我们不用,把它重载,定义大学生自己的交学费操作,这样当我们定义了一个小学生,一个大学生后:

    Student A;
    AcadStudent B;

    A.交学费(); 即调用小学生的,B.交学费();是调用大学生的,功能是实现了,但是你要意识到,可能情况不仅这两种,可能N种如:小学生、初中生、高中生、研究生.....
    它们都可以以Student[小学生类]为基类。

    如果系统要求你在一群这样的学生中,随便抽出一位交纳学费,你怎么做?

    :
    //A为抽出来的要交学费的同学
    {switch(typeof(A))
    {case 小学生:A.小学生:: 交学费 ();break;
    case 初中生:A.初学生:: 交学费 ();break;
    case 高中生:A.高学生:: 交学费 ();break;

    default:
    .............
    }
    }

    首先,我们要在每个类中定义一个 typeof()用来识别它的类型,然后还要在程序中进行区别,这样一来,虽然也行,但是,如果再增加类型则要改动switch,又走了面向过程的老路,而且想通过一个模块进行操作实现起来也有难度。
    所以C++中提供了多态,即能通过迟后联编的技术实现动态的区分。
    在基类的"交学费"前加个Virtual 用来告诉系统,遇到这个处理过程要等到执行时再确定到底调用哪个类的处理过程。这样一来就可以:

    void 通用的交学费操作 (Student &A)
    {A.交学费();
    }

    一下全部搞定,你再加新的类型我也不怕!!![具体的实现原理参考:《Inside The C++ Object Model》]。如果没有 virtual这一声明,那么,系统在执行前就确定了操作,比如把“大学生”传给
    void 通用的交学费操作 (Student &A)
    {A.交学费();
    }
    ,则A.交学费();调用的是大学生类中继承于Student类中的“交学费操作”
    所以虚函数对多态的实现是必要的。

    为什么会出现纯虚函数呢?

    如果按上面的例子进行编程,所有类型都继承小学生类,我们会发现一此小学生自己特定的东东[比如 void 上美术课();],也都被大学生继承来了,虽然不影响大学生的操作,但是随时间的加长,小学生类中自已所特定的东东越来越多,这样下去,大学生中冗余的数据就多了,有什么办法可以解决????

    就是定义基类时定义一个抽象类,如学生类,在学生类中实现一此大家都有的操作
    。这个过程就叫分解。
    这个类子对纯虚函数的说明还不够明显,换个例子比如:



    class 人()
    {public :
    //......
    void 吃()
    {人吃饭;
    }
    //......
    char *Name;
    int age;
    };

    class 狗()
    {public :
    //......
    void 吃()
    {狗吃屎;
    }
    //......
    char *Name;
    int age;
    };
    人类、狗类有一些相同的东东,如名字,年纪,吃的动作等,有人想到了为了代码的重用,让人类继承狗类,可是数据的冗余让这个想法完蛋了,所以有人又想出可不可以定义一个这样的类:


    这个类界于人类狗类之间,有人类和狗类共有的一些东东,比如年纪,名字,体重什么的,但它是不存在实例的,它的存在意义也是只是为了派生其它类,如人类、狗类,这样可以使系统清淅、。。。。。、、反正好处多多。

    在这个世界上根本不存在界于人狗之间的东东,所以这个“人狗之间类”中的“吃”也是没什么意义,你也很难为它的内容下个定义,况且也没必要,所以定义它为纯虚函数,形式为:virtual void 吃()=0; 用来告诉系统:
    1、这个函数可以没有函数定义;
    2、拥有本函数的类是抽象类;
    你可能会说,即然纯虚函数没什么意义,为什么还要它,它的作用是什么呢?
    为实现多态作准备!!!

    由于抽象类的实例没意义,所以C++中不允许定义它的实例。(如果定义了这样的实例A,那么你调用A.吃()怎么办?)


    当然了,你也可以在基类中,virtual 吃(){}
    这样一来,基类就不是抽象类了,可以有实例,而且对于其它方面都不影响。

    但你也要承认这样的对象是没有什么意识的,它的存在只能使你思考上增加负担,除错时还要考虑到是不是有这样类的对象在作怪,所以C++干脆提供了“虚函数”、抽象类,的机制,给我们操作时加了限制也可以认为是保险[不可以有抽象类的对象],试想当代码变得非常之庞大时,它的存在是多么有必要啊!!!

    展开全文
  • 如果是这种情况,那么 C++ 语言允许程序员将该函数声明为一个纯虚函数,也就是,一个中没有提供实现的成员函数。C++ 声明一个纯虚函数的方法是将表达式 =0 放在声明中,而函数的主体则不存在。例如,如果要将...

    在继承层次结构中,有一项很方便的做法,可以在基类中定义一个成员函数,该函数只能在每个派生类中实现,而不能由基类本身来实现,因为合理实现所需的细节只能在派生类中找到。

    如果是这种情况,那么 C++ 语言允许程序员将该函数声明为一个纯虚函数,也就是,一个在类中没有提供实现的成员函数。C++ 声明一个纯虚函数的方法是将表达式 =0 放在类声明中,而函数的主体则不存在。

    例如,如果要将一个成员函数 void draw() 声明为纯虚函数,那么它的类中的声明语句示例如下:

    void draw()= 0;

    纯虚函数有时称为抽象函数,而如果某个类至少有一个纯虚函数,那么它将被称为抽象类。C++ 编译器不允许实例化一个抽象类。抽象类只能被子类化,也就是说,只能使用它们作为派生其他类的基类。

    派生自抽象类的类将继承基类中的所有函数,除非它覆盖继承的所有抽象函数,否则它本身也是抽象类。抽象类的用处在于它定义了一个接口,接口必须由从它派生的所有类的对象来支持。

    可以把抽象类看作一个除子类外没有实例的类。现实生活中有许多抽象类的例子。例如,在动物王国中,"动物" 类就是所有动物的抽象类。所有动物的实例(例如狗、鸡、狐狸等)都属于 "动物" 抽象类中的某个子类,但 "动物" 本身不能实例化。

    现在来看一看由一个形状的集合组成的图形系统,这些形状必须绘制在屏幕的某些位置上。每个形状对象都有一些成员变量来记录它的位置,并且还有一个成员函数,用于在正确位置绘制形状。该系统支持的不同形状可能包括矩形、六边形和其他形状。

    因为矩形是一个形状,而六边形也是一个形状,所以单独创建一个 Shape 类是有意义的,然后就可以从 Shape 类中派生出 Rectangle 类和 Hexagon 类。Shape 类有一个成员函数 setPosition,将用于设置形状的位置;还有一个成员函数 Draw,用于绘制形状。但是,由于 Shape 是一个抽象类(没有任何形状可以是一个笼统概念上的“形状”,它必须是矩形、六边形、三角形或其他具体的形状),绘制一个特定形状的逻辑必须委托给一个合适的子类,因此,draw() 函数不能在 Shape 类中实现,必须将它声明为一个纯虚函数。

    下面的程序演示了上述 Shape 类,它具有两个派生类:Rectangle 和 Hexagon。该类声明了一个纯虚函数 draw(),该函数将由其两个子类实现。main 函数使用了一个指针矢量来维护一个 Shape 对象的集合。

    // This program demonstrates abstract base

    // classes and pure virtual functions.

    #include

    #include

    #include

    using namespace std;

    class Shape

    {

    protected:

    int posX, posY;

    public:

    virtual void draw() const =0;

    void setPosition(int pX, int pY)

    {

    posX = pX;

    posY = pY;

    }

    };

    class Rectangle : public Shape

    {

    public:

    virtual void draw() const

    {

    cout << "Drawing rectangle at " << posX << " " << posY << endl;

    }

    };

    class Hexagon : public Shape

    {

    public:

    virtual void draw() const

    {

    cout << "Drawing hexagon at " << posX << " " << posY << endl;

    }

    };

    int main()

    {

    // Create vector of pointers to Shapes of various types

    vector> shapes

    {

    make_shared(),

    make_shared(),

    make_shared()

    };

    // Set positions of all the shapes

    int posX = 5, posY = 15;

    for (int k = 0; k < shapes.size (); k++)

    {

    shapes[k]->setPosition(posX, posY);

    posX += 10;

    posY += 10;

    };

    // Draw all the shapes at their positions

    for (int j =0; j < shapes.size (); j++)

    {

    shapes[j]->draw();

    }

    return 0;

    }

    程序输出结果:

    Drawing hexagon at 5 15

    Drawing rectangle at 15 25

    Drawing hexagon at 25 35

    此程序提供了动态绑定和多态的另一个示例。来看以下声明:

    shapeArray[j]->draw();

    它将在循环中执行不同的次数。

    for (int j = 0; j

    {

    shapeArray[j]->draw();

    }

    第一次执行语句时,它将调用六边形对象的 draw 函数;而第二次执行时,它将调用矩形对象的 draw 函数。因为这两个 draw 函数是在不同的类中,所以它们会产生不同的行为。

    关于抽象基类和纯虚函数,请记住以下知识要点:

    当一个类包含一个纯虚函数时,它是一个抽象基类。

    抽象基类不能被实例化。

    纯虚函数用 =0 表达式声明,并且没有函数体或定义。

    在需要实例化的派生类中必须覆盖纯虚函数。

    展开全文
  • C++ 抽象类 纯虚函数定义  纯虚函数是在基类中声明的虚函数,它在基类中没有定义,但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0” 二、引入原因: 1、为了方便...
  • abstract class是抽象类至少包含一个纯虚函数的类就叫做抽象类。 但是如果一个类,所有的成员都是纯虚函数,那么它和一般的抽象类在用法上是区别的。至少Microsoft给的COM接口定义全部都是仅由纯虚函数构成的...
  • 什么是虚函数? 那些被virtual关键字修饰的成员函数,就是虚函数。虚函数的作用,用专业术语来解释就是实现多态性(Polymorphism),多态性是将接口与实现进行分离;用形象的语言来解释就是实现以共同的方法,但因...
  • C++中没有接口的概念,与之对应的是纯虚类,即只含有纯虚函数的类,C++抽象类的概念是...abstract class是抽象类至少包含一个纯虚函数的类就叫做抽象类。 但是如果一个类,所有的成员都是纯虚函数,那么它和一般的抽
  • 1:包含有纯虚函数的类称为抽象类,一个抽象类至少具有一个纯虚函数。抽象类只能作为基类派生出的新的子类,而不能在程序中被实例化(即不能说明抽象类的对象),但是可以使用指向抽象类的指针。在程序开发过程中并...
  • 包含有纯虚函数的类称为抽象类,一个抽象类至少具有一个纯虚函数。抽象类只能作为基类派生出的新的子类,而不能在程序中被实例化(即不能说明抽象类的对象),但是可以使用指向抽象类的指针。像在开发程序的过程中,...
  • c++中没有接口的概念,与之对应的是纯虚类,即只含有纯虚函数的类,c++抽象类的概念是含有纯虚函数成员的类。... abstract class是抽象类至少包含一个纯虚函数的类就叫做抽象类。 但是如果一个类,所有的成员
  • 抽象类纯虚函数

    2019-09-21 21:41:41
    抽象类的定义就是,含有纯虚函数的类。纯虚函数跟一般的虚函数很大不同。我们下面来了解下纯虚函数。 一.纯虚函数 即使的虚函数在基类中不需要做任何工作,我们也要写出一个空的函数体,这时这个函数体没有...
  • 纯虚函数抽象类

    2020-08-22 12:36:31
    (每一个有函数,在该对象的内存的第一块就是存放的虚函数表的地址) 在使用基类指针指向派生对象时,需要将基类的析构函数添加virtual关键字,将其变为虚析构函数。(否则在删除基类指针指向的额派生...
  • 纯虚函数抽象类

    2021-06-19 19:34:31
    title: 纯虚函数抽象类 date: 2021-06-19 16:56:53 tags: [C++] 纯虚函数抽象类 纯虚函数抽象类 纯虚函数:用 virtual 声明且赋值 0 的没有函数体的函数。 抽象类:包含纯虚函数的类。 抽象类的使用 抽象...
  • 在说明其作用前先看段代码 class A {  public: int iValue;  }; class B:public A {  public:  void bPrintf(){cout }; class C:public A { public:  void cPrintf(){cout  }; class D:public B,publi
  • C++里的抽象类纯虚函数

    千次阅读 2016-09-12 09:57:45
    C++里的抽象类纯虚函数在C++中,含有至少一个纯虚函数的类是抽象类,但是注意在C++中没有abstract这个关键字,所以C++里面的抽象类无需添加abstract这个单词。抽象类不可以直接实例化,也就是不能直接用抽象类来...
  • 2.如果一类含有至少一个纯虚函数,那么该类就是一个抽象类抽象类不能被实例化为对象 3.除了构造函数和析构函数以外全部成员函数都是纯虚函数抽象类叫做纯抽象类,亦称接口类 #include <iostream> using ...
  • 纯虚函数是在一个基类(父类)中说明的虚函数,在基类中没有定义,要求任何派生类(子类)都可以自己的版本。 纯虚函数的说明形式:virtual 类型 函数名(参数表)=0; class point{......}; class xxx; //抽象...
  • 4.纯虚函数 5.抽象类 6.虚基类 1.虚函数的引入 先看如下程序,程序后进一步的解释。如果读者对程序不懂请先复习基础知识。 // // VirtualFun.cpp // virtual // // Created by 刘一丁 on 2019/8/26. // ...
  • C++的抽象类纯虚函数类似于java中的接口和接口函数 在C++的程序设计中,常常希望基类只作为其派生类的一个...做到哦这点,可以在基类中加入至少一个纯虚函数,使得基类变为抽象类 1,纯虚函数使用关键字virtual,并在...
  • 一、基本概念 1、虚函数 在的成员函数前冠以 virtual 关键字的函数叫做虚函数。虚函数是实现运行时多态的基础,可以像普通函数一样被重载,也可以在派生中被...如果一个类至少有一个纯虚函数,那么这个...
  • c++的虚函数 有点类似于 android生命周期函数 , c++的基类虚函数可以实现,可以没有实现。派生继承基类后,可以选择重定义虚函数,也可以不重定义 。...c++的纯虚函数,这是在必须是public,例如 double net_pri

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,222
精华内容 2,488
关键字:

抽象类至少有一个纯虚函数