精华内容
下载资源
问答
  • 抽象类是具有纯虚函数的类
    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

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

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

    纯虚函数

    纯虚函数是指被标明为不具体实现的虚成员函数,它不具备函数的功能。
    许多情况下,在基类中不能给虚函数一个有意义的定义,这时可以在基类中将它说明为纯虚函数,而其实现留给派生类去做。纯虚函数不能被直接调用,仅起到提供一个与派生类相一致的接口的作用。
    声明纯虚函数的形式如下:
    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指向的对象不同,其行为也不同。

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

    2022-03-24 09:01:18
    当类中有了纯虚函数,这个类就称之为抽象类。 #include <iostream> using namespace std; //纯虚函数抽象类 class Base{ public: //父类虚函数实现是豪无意义的,可以修改为纯虚函数。 //纯虚函数语法...

    在多态中,通常父类中虚函数的实现是毫无意义的,主要是调用子类重写的内容。
    因此,我们可以将虚函数修改为纯虚函数。
    纯虚函数语法:virtual 返回值类型 函数名(参数列表) = 0;
    当类中有了纯虚函数,这个类就称之为抽象类。

    #include <iostream>
    using namespace std;
    
    //纯虚函数与抽象类
    class Base{
    public:
    	//父类虚函数实现是豪无意义的,可以修改为纯虚函数。
    	//纯虚函数语法:virtual 返回值类型 函数名(参数列表) = 0;
    	virtual void func() = 0;    //纯虚函数
    
    	//只要类中有一个纯虚函数,这个类称之为抽象类。
    	//抽象类的特点:
    	//1. 无法实例化对象
    	//2. 抽象类的子类必须重写父类的纯虚函数,否则也属于抽象类。
    };
    
    class Son:public Base{
    public:
    	//由于子类现在没有重写父类的纯虚函数,所以子类Son属于抽象类。
    	/*
    	virtual void func()
    	{
    		cout << "Son func()的调用" << endl;
    	}
    	*/
    };
    
    int main(int argc,char *argv[])
    {
    	//Base *b = new Son;  //父类指针指向子类对象
    	//b->func();
    	
    	//Base b;
    	//new Base;
    	
    
    	Son s;
    
    	return 0;
    }
    /********************************
    PS C:\Users\32781\Desktop\love_you\02> g++ .\demo1.cpp
    .\demo1.cpp: 在函数‘int main(int, char**)’中:
    .\demo1.cpp:37:6: 错误:不能将变量‘s’声明为具有抽象类型‘Son’
       37 |  Son s;
          |      ^
    .\demo1.cpp:17:7: 附注:因为下列虚函数在‘Son’中为纯虚函数:
       17 | class Son:public Base{
          |       ^~~
    .\demo1.cpp:9:15: 附注:        ‘virtual void Base::func()’
        9 |  virtual void func() = 0;    //纯虚函数
          |               ^~~~
    PS C:\Users\32781\Desktop\love_you\02>  
    ********************************/

    案例描述:
    制作饮品的大致流程为:煮水  --  冲泡   ---  倒入杯中   ---   加入辅料
    利用多态的技术实现本案例,提供抽象制作饮品类,提供子类制作咖啡与茶。

    例如:
    冲咖啡
    1、煮农夫山泉。    2、冲泡咖啡。
    3、倒入玻璃杯中。4、加糖与牛奶。

    冲茶
    1、煮矿泉水。       2、冲泡茶叶。
    3、倒入小茶杯中。4、加入柠檬。

    #include <iostream>
    using namespace std;
    
    //饮品抽象类
    class AbstractDrinking{
    public:
    	//煮水
    	virtual void Boil() = 0;
    
    	//冲泡
    	virtual void Brew() = 0;
    
    	//倒入杯中
    	virtual void PourInCup() = 0;
    
    	//加入辅料
    	virtual void PutSomething() = 0;
    
    	//制作饮品流程
    	void makeDrink()
    	{
    		Boil();
    		Brew();
    		PourInCup();
    		PutSomething();
    	}
    };
    
    class Coffee:public AbstractDrinking{
    public:
    	//子类重写父类的纯虚函数
    	virtual void Boil()
    	{
    		cout << "煮农夫山泉" << endl;
    	}
    
    	virtual void Brew()
    	{
    		cout << "冲泡咖啡豆" << endl;
    	}
    
    	virtual void PourInCup()
    	{
    		cout << "倒入玻璃杯中" << endl;
    	} 
    
    	virtual void PutSomething()
    	{
    		cout << "加入糖和牛奶" << endl;
    	}
    };
    
    class Tea:public AbstractDrinking{
    public:
    	//子类重写父类的纯虚函数
    	virtual void Boil()
    	{
    		cout << "煮矿泉水" << endl;
    	}
    
    	virtual void Brew()
    	{
    		cout << "冲泡茶叶" << endl;
    	}
    
    	virtual void PourInCup()
    	{
    		cout << "倒入小茶杯中" << endl;
    	} 
    
    	virtual void PutSomething()
    	{
    		cout << "加入柠檬" << endl;
    	}
    };
    
    
    
    void doWork(AbstractDrinking *abs)  //父类的指针指向子类的对象
    {
    	abs->makeDrink();
    	delete abs;
    }
    
    int main(int argc,char *argv[])
    {
    	doWork(new Coffee);
    
    	cout << "------------------" << endl;
    
    	doWork(new Tea);
    
    	return 0;
    }
    

    菱形继承

     

    解决菱形继承中的二义性问题

    1.通过域操作符指定使用哪一条路上的方法。 
          temp.base_a::show();  
          temp.base_b::show(); 
    
    2.在派派生类中重写出现二义性的接口
     class base_c : public base_a,public base_b
    {
    	public :
    	base_c(){cout << "base_c" << endl;}
    	~base_c(){cout << "~base_c" << endl;}
       void show()
       {
           cout <<  "show base_c"  << endl;
       }
    };

    .最优的解决方法,利用《虚继承》,把base放入虚表中

    /****************
    语法:
    class 类名: virtual 继承方式 父类名
    {
    };
    虚继承--(在创建对象的时候会创建一个虚表)
    A:virtual public D 
    B:virtual public D
    ****************/
    class base
    {
    };
    //虚继承 base ->base 就会放入虚表中
    class base_a : virtual  public base
    {
    };
    //虚继承 base ->base 就会放入虚表中 
    class base_b :virtual  public base
    {
    };
    //!! 所有亲缘关系的类共用一个虚表 
    class base_c : public base_a,public base_b
    {
    };

     

    展开全文
  • 纯虚函数的类,称为抽象类

    千次阅读 2021-06-05 22:11:14
    子类必须重写抽象类中的纯虚函数,否则也属于抽象类

    一、纯虚函数与抽象类


    在多态中,
    通常父类中虚函数本身的实现是毫无意义的,
    主要都是调用子类重写的内容。

    因此可以将虚函数改为纯虚函数,
    纯虚函数语法:virtual 返回值类型 函数名 (参数列表)= 0 ;

    当类中有了纯虚函数,这个类也称为抽象类。


    二、抽象类特点


    1、无法实例化对象
    2、子类必须重写抽象类中的纯虚函数,否则也属于抽象类


    class Base 	//抽象类 ( 类中只要有一个纯虚函数就称为抽象类 )
    {
    public:
    	virtual void func() = 0; 	//纯虚函数
    };
    
    class Son :public Base
    {
    public:
    	virtual void func()  	//子类必须 重写 父类中的纯虚函数,否则也属于抽象类
    	{
    		cout << "func调用" << endl;
    	};
    };
    
    
    int main() {
    
    	Base * base = NULL;
    	//base = new Base; // 错误,抽象类无法实例化对象
    	base = new Son;
    	base->func();
    	delete base; //记得销毁
    	return 0;
    }
    
    
    展开全文
  • 纯虚函数抽象类

    2019-05-27 21:51:48
    纯虚函数是一个在基类中说明的虚函数,在基类中没有定义,要求任何派生类都定义自己的版本 ... 一个具有纯虚函数的基类称为抽象类: 1,含有纯虚函数的类,称为抽象基类,不可实列化。即不能创建对象,存在 的意义 ...
  • C ++中的抽象类纯虚函数 (Abstract Class and Pure Virtual Function in C++) Abstract Class is a class which contains atleast one Pure Virtual function in it. Abstract classes are used to provide an ...
  • C++抽象类纯虚函数

    2021-04-14 01:43:03
    如果是这种情况,那么 C++ 语言允许程序员将该函数声明为一个纯虚函数,也就是,一个在中没有提供实现的成员函数。C++ 声明一个纯虚函数的方法是将表达式 =0 放在声明中,而函数的主体则不存在。例如,如果要将...
  • C++里的抽象类纯虚函数

    千次阅读 2016-09-12 09:57:45
    C++里的抽象类纯虚函数在C++中,含有至少一个纯虚函数的类是抽象类,但是注意在C++中没有abstract这个关键字,所以C++里面的抽象类无需添加abstract这个单词。抽象类不可以直接实例化,也就是不能直接用抽象类来...
  • c++之抽象类纯虚函数)的使用

    千次阅读 2018-05-08 07:42:08
    一、定义 当一个类中有纯虚函数时我们称这个类为抽象类抽象类不能直接定义为对象要通过继承的 方式来同过子类定义对象,但是抽象类可以定义指针。二、使用 1、抽象类和接口类的区别 (1)、c++中我们所说的...
  • 在介绍抽象类之前,我们先介绍一下纯虚函数。1.纯虚函数 在基类中仅仅给出声明,不对虚函数实现定义,而是在派生类中实现。这个虚函数称为纯虚函数。普通函数如果仅仅给出它的声明而没有实现它的函数体,这是编译...
  • 系列文章目录 第一章 c++继承 ...虚析构函数5.final成员函数和类三、抽象类纯虚函数1.抽象类2.纯虚函数总结 前言 最近在准备研究生复试,学习c++,就当作是学习笔记了 一、类继承层次中对象之间的
  • 纯虚函数抽象类 、多重继承 、二义性问题 、菱形继承 、虚基类 、从内存布局看虚继承的底层实现原理
  • 纯虚函数
  • 由于未使用的函数实体是一种浪费,可以把函数实体省略掉,无函数实体的虚函数叫做纯虚函数。 /*纯虚函数的定义和使用*/ #include<iostream> using namespace std; class test1 { int x; int y; public: ...
  • 纯虚函数是一个在基类中只有声明的虚函数,在基类中无定义。要求在任何派生中都定义自己的版本; b. 纯虚函数为各派生提供一个公共界面(接口的封装和设计,软件的模块功能划分); c. 纯虚函数声明形式:
  • 抽象类函数 在默认情况下对函数成员调用实施的是静态连编,也叫做静态绑定。如果子类中的函数fff覆盖了父类中的函数fff,那么基类中的其他函数调用函数fff的时候调用的仍然是基类中的函数而不是子类的。 为了解决...
  • //纯虚函数 } 纯虚函数的作用: 1、抽象类为抽象和设计的目的而声明的,将有关的数据和行为组织在一个继承层次结构中,保证派生类具有要求的行为; 2、对于暂时无法实现的函数,可以声明为纯虚函数,留给派生类去...
  • RTTI就是运行时的类型信息RTTI指针存储在虚函数表vftable当中,指向一段类型字符串 抽象类纯虚函数 含有纯虚函数的类称为抽象类,一般情况下是一个基类,它不代表任何实体 ,因此不用实例化对象 ,他只是给派生类...
  • 为什么要引入抽象基类和纯虚函数?主要目的是为了实现一种接口的效果。   ...抽象类是一种特殊的类,它是为了抽象和设计的目的... ⑴抽象类的定义:带有纯虚函数的类为抽象类。       ...
  • c++(虚函数、纯虚函数抽象类

    千次阅读 2019-04-29 20:23:03
    二、纯虚函数 三、抽象类 1.1 注意: 1.2程序举例 一、虚函数 1.1问题引入 c++在默认情况下,对函数成员的调用实施的是静态连编(staticbinding),也叫静态绑定。 此时,如果子类中的函数F覆盖了基类的函数F...
  • 多态3、虚析构函数4 、纯虚函数抽象类①、纯虚函数②、抽象类(包含纯虚函数) 一、继承 1、继承概念 在原有类的基础上派生出新的类,新类继承原有类的属性和方法,称原有的类为基类, 又称为父类。由已存在的类...
  • 虚函数的访问指针访问引用访问对象访问成员函数中的访问构造函数和析构函数中访问纯虚函数抽象类虚析构函数重载、隐藏、覆盖虚拟继承虚拟继承时派生类对象的构造和析构 什么是多态? **多态性( polymorphism )**是...
  • 代码实例三、内部类----》类的嵌套四、纯虚函数抽象类1.纯虚函数2.抽象类3.代码实例总结 前言 C++精准知识讲解 提示:以下是本篇文章正文内容,下面案例可供参考 一、类的大小跟static的关系 更新类的大小:类的...
  • 一、纯虚函数抽象类 1.下列关于纯虚函数抽象类的描述中,错误的是( )。 C.一个基类的说明中有纯虚函数,该基类的派生类一定不再是抽象类 抽象类派生的类必须提供纯虚函数的实现代码,或在该派生类中仍将...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,371
精华内容 4,148
关键字:

抽象类是具有纯虚函数的类