精华内容
下载资源
问答
  • C++学习笔记之纯虚函数和抽象类/纯虚函数和抽象类的学习/纯虚函数和抽象类学习 在多态中,通常父类中虚函数的实现是无意义的,主要就是调用子类重写的内容因此...子类必须重写抽象类的纯虚函数,否则也属于抽象类 ...

    C++学习笔记之纯虚函数和抽象类/纯虚函数和抽象类的学习/纯虚函数和抽象类学习
    在多态中,通常父类中虚函数的实现是无意义的,主要就是调用子类重写的内容因此可以将虚函数改为纯虚函数
    纯虚函数语法:

    virtual 返回值类型 函数名 (参数列表) = 0;
    

    当类中纯虚函数,这个类也称为抽象类
    抽象类的特点
    无法实例化对象
    子类必须重写抽象类的纯虚函数,否则也属于抽象类

    #include <iostream>
    using namespace std;
    //在多态中,通常父类中虚函数的实现的毫无意义的主要都是调用重写的内容
    //因此可以将虚函数改为纯虚函数
    //纯虚函数: virtual 返回值类型 函数名(参数列表 ) = 0
    //抽象类特点:
    //1. 无法实例化对象
    //2. 子类必须是重写抽象类中的纯虚函数, 否则也属于抽象类
    
    class Base
    {
    public:
    	//纯虚函数
    	//类中只要有一个纯虚函数就称为抽象类
    	//抽象类无法实例化对象
    	//子类必须重写父类中的纯虚函数, 否则也属于抽象类
    	virtual void func() = 0;
    };
    class Son : public Base
    {
    public:
    	virtual void func()
    	{
    		cout << "func调用" << endl;
    	}
    };
    void test()
    {
    	Base* base = NULL;
    	//Base* base = new Base;	错误,抽象类无法实例化对象
    	base = new Son;
    	//使用父类指针指向子类对象
    	base->func();
    	delete base;	//记得销毁
    }
    int main()
    {
    	test();
    	return 0;
    }
    

    C++学习笔记之纯虚函数和抽象类/纯虚函数和抽象类的学习/纯虚函数和抽象类学习

    展开全文
  • 包含有纯虚函数的类称为抽象类,一个抽象类至少具有一个纯虚函数。抽象类只能作为基类派生出的新的子类,而不能在程序中被实例化(即不能说明抽象类的对象),但是可以使用指向抽象类的指针。像在开发程序的过程中,...

    包含有纯虚函数的类称为抽象类,一个抽象类至少具有一个纯虚函数。抽象类只能作为基类派生出的新的子类,而不能在程序中被实例化(即不能说明抽象类的对象),但是可以使用指向抽象类的指针。像在开发程序的过程中,并不是所有代码都是由软件构造师自己写的,有时候需要调用库函数,有时候分给别人来写。一名软件构造师可以通过纯虚函数建立接口,然后让程序员填写代码实现接口,而自己主要负责建立抽象类。

    纯虚函数

    纯虚函数是指被标明为不具体实现的虚成员函数,它不具备函数的功能。
    许多情况下,在基类中不能给虚函数一个有意义的定义,这时可以在基类中将它说明为纯虚函数,而其实现留给派生类去做。纯虚函数不能被直接调用,仅起到提供一个与派生类相一致的接口的作用。
    声明纯虚函数的形式如下:
    virtual 类型 函数名(参数列表)=0;
    纯虚函数不可以被继承。当基类是抽象类时,在派生类中必须给出基类中纯虚函数的定义,或者在该类中再声明其为纯虚函数。只有在派生类中给出了基类中所有纯虚函数的实现时,该派生类才不再成为抽象类。

    例子:
    创建纯虚函数

    #include<iostream>
    using namespace std;
    
    class Figure
    {
    public:
    	virtual double getArea() = 0;
    };
    
    const double PI = 3.14;
    
    class Circle:public Figure
    {
    private:
    	double Radius;
    	
    public:
    	Circle(double R)
    	{
    		Radius = R;
    	}
    	double getArea()
    	{
    		return Radius * Radius * PI;
    	}
    };
    
    class Rectangle:public Figure
    {
    protected:
    	double Height,Width;
    
    public:
    	Rectangle(double height,double width)
    	{
    		Height = height;
    		Width = width;
    	}
    	double getArea()
    	{
    		return Height * Width;
    	}
    };
    
    int main()
    {
    	Figure *fg1;
    	fg1 = new Rectangle(4.0,5.0);
    	cout << fg1->getArea() << endl;
    	delete fg1;
    	Figure *fg2;
    	fg2 = new Circle(4.0);
    	cout << fg2->getArea() << endl;
    	delete fg2;
    	return 0;
    }
    

    注意:
    对于包含纯虚函数的类来说,是不能够实例化的,“Figure figure;”是错误的。
    结果:
    image.png
    程序定义了矩形类Rectangle和圆形类Circle,两个类都派生于图形类Figure。图形类是一个在现实生活中不存在的对象,抽象类面积的计算方法不确定,所以,将图形类Figure的面积计算方法设置为纯虚函数,这样圆形有圆形面积的计算方法,矩形有矩形面积的计算方法,每个继承自Figure的对象都有自己的面积,通过getArea成员函数就可以获取面积值。

    实现抽象类中的成员函数

    抽象类通常用于作为其他类的父类,从抽象类派生的子类如果不是抽象类,则子类必须实现父类中的所有纯虚函数。

    例子:

    #include<iostream>
    using namespace std;
    
    class CEmployee
    {
    public:
    	int m_ID;
    	char m_Name[128];
    	char m_Depart[128];
    	virtual void OutputName() = 0;  //定义抽象成员函数
    };
    
    class COperator:public CEmployee
    {
    public:
    	char m_Password[128];
    	void OutputName()  //实现父类中的纯虚成员函数
    	{
    		cout << "Operator's name:" << m_Name << endl;
    	}
    	COperator()
    	{
    		strcpy(m_Name,"Johnson");
    	}
    };
    
    class CSystemManager:public CEmployee
    {
    public:
    	char m_Password[128];
    	void OutputName()  //实现父类中的纯虚成员函数
    	{
    		cout << "SystemManager's name:" << m_Name << endl;
    	}
    	CSystemManager()
    	{
    		strcpy(m_Name,"Johnson666");
    	}
    };
    
    int main()
    {
    	CEmployee *pWorker;
    	pWorker = new COperator();
    	pWorker->OutputName();
    	delete pWorker;
    	pWorker = NULL;
    	pWorker = new CSystemManager();
    	pWorker->OutputName();
    	delete pWorker;
    	pWorker = NULL;
    	return 0;
    }
    

    结果:
    image.png
    程序中从CEmployee类派生了两个子类,分别为COperator和CSystemManager。这两个类分别实现了父类的纯虚成员函数OutputName。同样的一条语句“pWorker->OutputName();”,由于pWorker指向的对象不同,其行为也不同。

    展开全文
  • 抽象类纯虚函数

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

      抽象类的定义就是,含有纯虚函数的类。纯虚函数跟一般的虚函数有很大不同。我们下面来了解下纯虚函数。

     一.纯虚函数

           即使有的虚函数在基类中不需要做任何工作,我们也要写出一个空的函数体,这时这个函数体没有什么意义,重要的是此虚函数的原型声明。C++为我们提供了纯虚函数,让我们在这种情况下不用写函数实现,只给出函数原型作为整个类族的统一接口就可以了,函数的实现可以在派生类中给出。

           纯虚函数是在基类中声明的,声明形式为:

           virtual 函数类型 函数名(参数表) = 0;

           大家可以看到,纯虚函数的声明形式与一般虚函数类似,只是最后加了个“=0”。纯虚函数这样声明以后,在基类中就不再给出它的实现了,各个派生类可以根据自己的功能需要定义其实现。

           二.抽象类

           上面说到,抽象类就是含有纯虚函数的类。抽象类可以为某个类族定义统一的接口,接口的具体实现是在派生类中给出。这种实现就具有多态特性。

           这里要注意的是,抽象类的派生类如果没有实现所有的纯虚函数,只给出了部分纯虚函数的实现,那么这个派生类仍然是抽象类,仍然不能实例化,只有给出了全部纯虚函数的实现,派生类才不再是抽象类并且才可以实例化。

           我们不能声明抽象类的对象,使用抽象类一般是通过声明抽象类的指针或引用,将指针或引用指向派生类的对象,访问派生类的成员。

    程序如下:
        
           #include <iostream>
           using namespace std;
           class Base           // 抽象类Base的声明
           {
           public:
                     virtual void show() = 0;      // 纯虚函数成员show
           };
           class Child0 : public Base     // 类Base的公有派生类Child0的声明
           {
           public:
                     void show()    { cout << "Child0::show()" << endl; }    // 虚成员函数show
           };
           class Child1 : public Child0   // 类Child0的公有派生类Child1的声明
           {
           public:
                     void show()    { cout << "Child1::show()" << endl; }    // 虚成员函数show
           };
           void CallShow(Base *pBase)     // 一般函数,参数为基类指针
           {
                    pBase->show();
           }
           int main()
           {
                   Base *pBase;             // 声明Base类的指针
                   Child0 ch0;                 // 声明Child0类的对象
                   Child1 ch1;                 // 声明Child1类的对象
                   pBase = &ch0;           // 将Child0类对象ch0的地址赋值给Base类指针pBase
                   CallShow(pBase);
                   pBase = &ch1;           // 将Child1类对象ch1的地址赋值给Base类指针pBase
                   CallShow(pBase);
                   return 0;
           }

           程序运行结果为:

           Child0::show()
           Child1::show()

           这里派生类Child0和Child1的虚函数show并没有使用关键字virtual显式说明,因为Child0和Child1中的虚函数和基类Base中的纯虚函数名称一样,参数和返回值都相同,编译器会自动识别其为虚函数。

           上面的程序中,基类Base是抽象类,为整个类族提供了统一的外部接口。派生类Child0中给出了全部纯虚函数的实现(其实只有一个纯虚函数--show),因此不再是抽象类,可以声明它的对象。Child0的派生类Child1当然也不是抽象类。根据赋值兼容规则,基类Base的指针可以指向派生类Child0和Child1的对象,通过此指针可以访问派生类的成员,这样就实现了多态。

    参考:

    [1] http://www.jizhuomi.com/software/125.html

    展开全文
  • 纯虚函数的意义就是将派生类的共同特性提取出来。 虚函数和纯虚函数的区别:虚函数在基类中有实现,并且派生类无需一定要继承,派生类可以继承并且重写,实现多态。 抽象类:一个类中含有一个或者多个纯虚函数,...

    纯虚函数:纯虚函数就在基类中只是定义并不实现,需要在派生类中继承并且实现。纯虚函数的意义就是将派生类的共同特性提取出来。

    虚函数和纯虚函数的区别:虚函数在基类中有实现,并且派生类无需一定要继承,派生类可以继承并且重写,实现多态。

    抽象类:一个类中含有一个或者多个纯虚函数,那么这个类就是抽象类。不能实例化对象,只能定义指针,指向派生类以实现多态。

    代码示例:

    // ConsoleApplication1.cpp : 定义控制台应用程序的入口点。
    //
    
    // test.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <iostream>
    #pragma warning(disable:4996)
    #include <string>
    
    using namespace std;
    
    /*一个类中含有一个或者多个纯虚函数,那么这个类就是抽象类。
    纯虚函数的意义就是将派生类的共同特性提取出来
    */
    class coder{
    public:
    	virtual void sleep() = 0;
    							//不能实例化对象,只能定义指针,指向派生类以实现多态。
    							//纯虚函数就像这个类中描述的一样,只是定义并不实现,需要在派生类中继承并且实现。
    							/*虚函数和纯虚函数的区别是:虚函数在基类中有实现,
    							并且派生类无需一定要继承,派生类可以继承并且重写,实现多态*/
    	virtual void eat() = 0;
    	virtual void code() = 0;
    };
    
    class c_coder :public coder{
    public:
    	void sleep(void){
    		cout << "c_coder sleep" << endl;
    	}
    	void eat(void){
    		cout << "c_coder eat" << endl;
    	}
    	void code(void){
    		cout << "c_coder code" << endl;
    	}
    };
    
    class cpp_coder :public coder{
    public:
    	void sleep(void){
    		cout << "cpp_coder sleep" << endl;
    	}
    	void eat(void){
    		cout << "cpp_coder eat" << endl;
    	}
    	void code(void){
    		cout << "cpp_coder code" << endl;
    	}
    };
    int main(int argc, char *argv[])
    {
    	//coder coder0;  //此处报错,不允许使用抽象类
    	coder *pcoder0;//这里就是可以的,这个指针可以指向派生类实现多态
    	c_coder a;
    	cpp_coder b;
    
    	pcoder0 = &a;
    	pcoder0->code();
    	pcoder0->eat();
    	pcoder0->sleep();
    
    	pcoder0 = &b;
    	pcoder0->code();
    	pcoder0->eat();
    	pcoder0->sleep();
    
    	return 0;
    
    }
    
    

    执行结果:

    展开全文
  • 3.继承自抽象类的子类,必须要实现父类的纯虚函数才可以实例化对象 4.抽象类不允许实例化对象,只能作为一个基类或虚接口使用 5.抽象类的指针可以指向不同的派生类对象(虚函数的功能) class Father{ public: ...
  • C++里的抽象类纯虚函数

    千次阅读 2016-09-12 09:57:45
    C++里的抽象类和纯虚函数...抽象类不可以直接实例化,也就是不能直接用抽象类来定义对象,只有实现了父类所有纯虚方法并且不包含纯虚函数的子类才能实例化。 来看一个示例: #include <iostream> using namespace std;
  • 1:包含有纯虚函数的类称为抽象类,一个抽象类至少具有一个纯虚函数。抽象类只能作为基类派生出的新的子类,而不能在程序中被实例化(即不能说明抽象类的对象),但是可以使用指向抽象类的指针。在程序开发过程中并...
  • 在Java、C#中有关键词abstract指明抽象函数、抽象类,但是在C++中没有这个...他派生的类的纯虚函数没有被改写,那么它的派生类还是个抽象类。定义纯虚函数就是为了让基类不可实例化化,因为实例化这样的抽象数据结构本
  • C++抽象类的纯虚函数

    2013-08-27 16:08:25
    在基类中实现纯虚函数的方法是在函数原型后加"=0" ,同 java中抽象方法类似 virtual void funtion1()=0  二、引入原因: 1、为了方便使用多态特性,我们常常需要在基类中定义虚拟函数。 2、在很多情况下,...
  • 抽象类纯虚函数

    2017-08-15 22:07:53
     在许多情况下,在基类中不能对虚函数给出有意义有实现,而把它说明为纯虚函数,它的实现留给该基类的派生去做。这就是纯虚函数的作用。下面给出一个纯虚函数的例子。  #include  class point
  • 在Java、C#中有关键词abstract指明抽象函数、抽象类,但是在C++中没有这个...他派生的类的纯虚函数没有被改写,那么它的派生类还是个抽象类。定义纯虚函数就是为了让基类不可实例化化,因为实例化这样的抽象数据结构本
  • 3、可以定义抽象类的指针或引用; 4、含有纯虚函数的类即为抽象类; 二、纯虚函数 1、纯虚函数定义:virtual 返回类型 函数名(参数表)= 0 2、纯虚函数具体实现只能在派生类中完成; #include<iostream> ...
  • 在本篇文章中,我们主要介绍虚函数抽象类的内容,自我感觉有个不错的建议和大家分享下 1、在基类中不能给出有意义的虚函数定义,这时可以把它说明成纯虚函数,把它的定义留给派生类来做 2、定义纯虚函数: class 类名...
  • 包含纯虚函数的类称为抽象类 (1) 抽象类只能用作其他类的基类,不能定义抽象类的对象 (2) 抽象类不能用于参数类型 函数返回值 或 显示转换的类型 (3) 抽象类可以定义抽象类的指针和引用,此指针可以指向它的派生类,...
  • c++抽象类纯虚函数

    2015-01-20 19:50:00
    抽象类是为了抽象和设计的目的而建立的,处于继承...(3)可以定义指向抽象类的指针和引用,此指针可以指向它的派生类,进而实现多态 纯虚函数是被标明为不具体实现的虚函数 virtual 类型 函数名(参数名)=0; ...
  • C++_抽象类纯虚函数

    2019-04-09 09:07:56
    抽象类实例 #include <iostream> using namespace std; class Figure { ... //阅读一个统一的界面(接口),让子类使用,让... //纯虚函数的写法,在各个派生类中实现。 private: }; class Circle:public Figure...
  • c++中的抽象类纯虚函数

    千次阅读 2013-05-22 23:08:08
    1、在基类中不能给出有意义虚函数定义,这时可以把它说明成纯虚函数,把它定义留给派生来做 2、定义纯虚函数:  class 类名{  virtual 返回值类型 函数名(参数表) = 0;  }; 3、纯虚函数不需要实现 ...
  • 纯虚函数抽象类 、多重继承 、二义性问题 、菱形继承 、虚基类 、从内存布局看虚继承底层实现原理
  • 抽象基类和纯虚函数

    2019-09-17 20:43:04
    纯虚函数:虚函数只有声明,函数体=0,就是一个纯虚函数,纯虚函数没有函数体...子类必须实现抽象基类中所有的纯虚函数,因为如果子类不实现所有纯虚函数,那么该子类依然是一个抽象类,没有办法实例化。(换一种说...
  •  抽象类的主要作用是将有关的操作作为结果接口组织在一个继承层次结构中,由它来为派生类提供一个公共的根,派生类将具体实现在其基类中作为接口的操作。所以派生类实际上刻画了一组子类的操作接口的通
  • 在C++中,我们可以把只能用于被继承而不能直接创建对象类设置为抽象类( Abstract Class) 我们把那些类中明确存在,但是在父类中无法确定具体实现的成员函数称为纯虚函数纯虚函数是一种特殊虚函数...
  • C++ 抽象类纯虚函数

    2015-02-10 09:00:09
    抽象类是为了抽象和设计的目的而建立的,处于继承层次结构的上层。 具体类是能够建立对象的类。...(3)可以定义指向抽象类的指针和引用,此指针可以指向它的派生类,进而实现多态性。 #include using namespace

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,687
精华内容 674
关键字:

抽象类的纯虚函数的实现