精华内容
下载资源
问答
  • 抽象类可以说明虚函数
    千次阅读
    2018-04-25 20:33:02
    虚函数 
    1, 虚函数是非静态的、非内联的成员函数,而不能是友元函数,但虚函数可以在另一个类中被声明为   友元函数。 
    2, 虚函数声明只能出现在类定义的函数原型声明中,而不能在成员函数的函数体实现的时候声明。 
    3, 一个虚函数无论被公有继承多少次,它仍然保持其虚函数的特性。 
    4, 若类中一个成员函数被说明为虚函数,则该成员函数在派生类中可能有不同的实现。
       当使用该成员函数操作指针或引用所标识的对象时 ,对该成员函数调用可采用动态联编。 
    5, 定义了虚函数后,程序中声明的指向基类的指针就可以指向其派生类。在执行过程中,该函数可以   不断改变它,在派生类中重新定义虚函数时,virtual可写可不写
    6 只有protected,public成员才能被声明为虚函数
    编译器在发现虚函数时,会为每个包含虚函数的类创建一个虚表,是一个一维数组,用来存放每个虚函数的地址
    class a
    {
    	public:
    		void fo()
    		{cout << "a->fo" << endl;}
    }
    class b:a
    {
    	public:
    		void fo()
    		{cout << "b->fo" << endl;}
    }
    
    int main()
    {
    	a *m;
    	a t;
    	b k;
    	m = &t;
    	cout << m.fo() << endl; // output1
    	m = &k;
    	cout << m.fo() << endl; //output2
    }
    此时两种输出都是"a->fo"
    如果把基类的fo函数设置为虚函数,virtual void fo(){cout << "a->fo" << endl;}
    那么输出就会变为 a->fo 和 b->fo
    抽象类:
    是带有纯虚函数的类,为了通过抽象类多态使用其中的成员函数
    纯虚函数 - virtual void set() = 0;
    为派生类提供一个一致的接口,纯虚函数的实现可以留给派生类来做
    抽象类不能创建对象,如果派生类没有改写纯虚函数,那么其派生类仍然是抽象类
    更多相关内容
  •  在许多情况下,在基类中不能对虚函数给出有意义有实现,而把它说明为纯虚函数,它的实现留给该基类的派生类去做。这是纯虚函数的作用。下面给出一个纯虚函数的例子。   #include class point//抽象类 { ...
  • 抽象类只能作为基类派生出的新的子类,而不能在程序中被实例化(即不能说明抽象类的对象),但是可以使用指向抽象类的指针。像在开发程序的过程中,并不是所有代码都是由软件构造师自己写的,有时候需要调用库函数,...

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

    纯虚函数

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

    展开全文
  • c++(虚函数、纯虚函数和抽象类

    千次阅读 2019-04-29 20:23:03
    三、抽象类 1.1 注意: 1.2程序举例 一、虚函数 1.1问题引入 c++在默认情况下,对函数成员的调用实施的是静态连编(staticbinding),也叫静态绑定。 此时,如果子类中的函数F覆盖了基类的函数F,那么基类中的...

    目录

     

    一、虚函数

    1.1 问题引入

    1.2 虚函数

    二、纯虚函数

    三、抽象类

    1.1 注意:

    1.2程序举例


    一、虚函数

    1.1 问题引入

    c++在默认情况下,对函数成员的调用实施的是静态连编(static binding),也叫静态绑定

    此时,如果子类中的函数F覆盖了基类的函数F,那么基类中的其他函数调用函数F的时候,调用的仍然是基类中的这个函数F,而不是子类中覆盖的那个。

    这时在某些应用下会出现一个问题,考虑下面的程序:

    //基类
    class Meter
    {
    private:
        float dataMeter;
    
    public:
        void setData(float m)
        {
            dataMeter = m;
        }
        float getData(){return dataMeter;}
        float dataSquare(){return getData()*getData();}
    };
    //子类
    class Centimeter:public Meter
    {
    private:
        float dataCentimeter;
    public:
        //覆盖基类的setdata
        void setData(float m)
        {
            dataCentimeter = m;
            Meter::setData(dataCentimeter/10.0f);
        }
        //覆盖基类的getdata
        float getData(){return dataCentimeter;}
    };

    在主函数中,实例化一个子类的对象,并利用其在基类中继承来的datasquare函数输出数据的平方:

    int main()
    {
        Centimeter cm;
    
        cout << "plesase input the cm:";
        float temp;
        cin>>temp;
        cm.setData(temp);
    
        cout<<"the cm you input is:"<<cm.getData()<<"cm\n\n";
        //利用继承的基类的平方函数输出其数据的平方
        cout<<"square of it is:"<<cm.dataSquare()<<"cm\n\n";
    
        return 0;
    }

    运行结果:

    这个结果显然是不对的,主要原因就是datasquare函数调用的仍然是基类的getdata函数,不会因为子类覆盖了这个getdata而就调用子类的getdata。也就是说普通函数成员不会因为子类的覆盖而改变其被调用时的指向

    要想实现由调用对象而改变其调用的函数,需要用到虚函数。

    1.2 虚函数

    • 虚函数也是一个函数成员,他要求在子函数中对其进行覆盖。
    • 对于虚函数,编译器完成的是动态连编(dynamic binding),也叫动态绑定
    • 对虚函数的调用是在程序运行时确定的

    这里例子中我们可以将getdata函数设置为虚函数,只需要在基类和子类的getdata函数的前面都加上virtual关键字即可。

    此时的运行结果:

    bingo!

    二、纯虚函数

    • 纯虚函数也是一个函数成员,是一个在基类中说明的虚函数,并没有具体的函数代码。
    • 各个派生类可以根据自己的需要,分别覆盖它,从而实现真正意义上的多态。

    纯虚函数声明格式:

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

    例如:

    virtual void showInfo()=0;

    三、抽象类

    1.1 注意:

    • 如果一个类具有一个或者多个纯虚函数,那么它就是一个抽象类,必须让其他类继承它。
    • 抽象类位于类层次的上层,不能定义抽象类的对象。
    • 基类中的纯虚函数没有代码,而且必须在子类中覆盖基类中的纯虚函数。

    1.2程序举例

    定义如下抽象类和继承子类:

    //定义一个抽象类
    class People
    {
    protected:
        char name[50];
        int age;
    public:
        People()
        {
            name[0] = age = 0;
        }
        //纯虚函数
        virtual void setData(char *,int) = 0;
    };
    //抽象类的子类
    class Andrew:public People
    {
    public:
        //覆盖基类的纯虚函数
        void setData(char *n,int a)
        {
            strcpy(name,n);
            age = a;
        }
        char *getName(){return name;}
        int getAge(){return age;}
    };

    主函数测试:

        Andrew qianshuai;
    
        qianshuai.setData("qianshuai",22);
    
        cout<<"qinashuai's info:\n";
        cout<<"name:"<<qianshuai.getName()<<endl;
        cout<<"age:"<<qianshuai.getAge()<<endl;

    正常输出:

    bingo!

    展开全文
  • 3.关于虚函数的几点说明 4.纯虚函数 5.抽象类 6.虚基类 1.虚函数的引入 先看如下程序,程序后有进一步的解释。如果读者对程序不懂请先复习基础知识。 // // VirtualFun.cpp // virtual // // Created by 刘...

    目录

    1.虚函数的引入

    2.虚函数作用

    3.关于虚函数的几点说明

    4.纯虚函数

    5.抽象类

    6.虚基类


    1.虚函数的引入

    先看如下程序,程序后有进一步的解释。如果读者对程序不懂请先复习基础知识。

    //
    //  VirtualFun.cpp
    //  virtual
    //
    //  Created by 刘一丁 on 2019/8/26.
    //  Copyright © 2019年 LYD. All rights reserved.
    //
    
    
    //file1.cpp
    #include <iostream>
    using namespace std;
    
    class Base                                  //基类 Base
    {
    public:
        Base(int x, int y)
        { a = x; b = y; }
        //virtual void show()                   //采用虚函数解决同名函数调用问题
        void show()                             //基类成员函数 show()
        {
            cout << "base++++++" << endl;
            cout << a << "  " << b << endl;
        }
        
    private:
        int a, b;
    };
    
    class Derived:public Base                    //派生类 Derived
    {
    public:
        Derived(int x, int y, int z):Base(x, y)
        { c = z; }
        void show()                              //派生类成员函数 show()
        {
            cout << "Derived+++++++"  << endl;
            cout << " c= " << c << endl;
        }
        
    private:
        int c;
    };
    
    int main()
    {
        Base mb(60, 60), *pc;                    //定义基类对象及指向基类的指针(简称基类指针)
        Derived mc(10, 20, 30);                  //定义派生类对象
        pc = &mb;                                //基类指针指向基类对象 mb
        pc-> show();
        pc = &mc;                                //基类指针指向派生类对象 mc
        pc-> show();
        
        return 0;
    }
    
    //output:
    //base++++++++
    //60  60
    //base++++++++
    //10  20
    
    

    注:

    C++中规定:基类的对象指针可以指向它公有派生的对象,但是当其指向公有派生类对象时,它只能访问派生类中从基类继承来的成员,而不能访问公有派生类中定义的成员,解决这个问题的方法就是引入虚函数。

    虚函数通常和指针连用,来体现动态的多态性。使用指针的目的是为了表达一种动态的特性,即当指针指向不同对象(基类或派生类对象)时,分别调用不同类的成员函数。

    2.虚函数作用

    在上文中虽然基类指针 pc 已经指向了派生类对象 mc,但是它所调用的成员函数 show() 仍然是其基类对象的 show()。解决方法有三种。

    ①mc.show();

    ②((Derived*)pc)-> show();

    ③将基类中的同名函数声明为虚函数,即在对应成员函数前加上关键字 virtual,并在派生类中被重载。

    虚函数更该方法即是代码中注释的部分,virtual void show();函数输出结果如下:

    base++++++++
    60  60
    Derived+++++
    c = 30

    3.关于虚函数的几点说明

    (1)C++规定,如果在派生类中,没有用 virtual 显式地给出虚函数声明,这是系统就会遵循以下规则来判断一个成员函数是否是虚函数。

    ①该函数与基类的虚函数有相同的名称。

    ②该函数与基类的虚函数有相同的参数个数及相同的对应参数类型。

    ③该函数与基类的虚函数有相同的返回类型或者满足赋值兼容规则的指针、引用型的返回类型。

    (2)通过虚函数来使用多态性机制,派生类必须从他的基类公有派生(赋值兼容规则)。

    (3)虚函数必须是其所在类的成员函数,而不能是友元函数,也不能是静态成员函数,因为虚函数调用哪个要靠特定的对象来决定该激活哪个函数。

    (4)构造函数不能是虚函数,通常把析构函数声明为虚函数(请读者自行百度)。

    4.纯虚函数

    基类往往表示一种抽象的概念,它并不与具体的事物相联系。这时在基类中将某一成员函数定义为虚函数,并不是基类本身的要求,而是考虑到派生类的需要,在基类中预留了一个函数名,具体功能留给派生类根据需要去定义。

    纯虚函数是在声明虚函数时被“初始化”为 0 的函数。例如

    virtual void show() = 0;

    纯虚函数的作用是在基类中为其派生类保留一个函数的名字,以便派生类根据需要对他进行重新定义。纯虚函数没有函数体,它最后面的“ = 0” 并不表示函数的返回值为 0,它只起形式上的作用,告诉编译系统“这是纯虚函数”。纯虚函数不具备函数的功能,不能被调用。

    //
    //  VirtualFun.cpp
    //  Virtual
    //
    //  Created by 刘一丁 on 2019/8/26.
    //  Copyright © 2019年 LYD. All rights reserved.
    //
    
    
    //file1.cpp
    #include <iostream>
    using namespace std;
    
    class Circle
    {
    public:
        void set(int x)
        { r = x; }
        virtual void show() = 0;   //定义纯虚函数
    protected:
        int r;
    };
    
    class Area:public Circle
    {
    public:
        void show()
        { cout << "Area is " << 3.14 * r * r << endl; }
    };
    
    class Perimeter:public Circle
    {
    public:
        void show()
        { cout << "Primeter is " << 2 * 3.14 * r << endl; }
    };
    
    int main()
    {
        Circle *ptr;
        Area ob1;
        Perimeter ob2;
        
        ob1.set(10);
        ob2.set(10);
        
        ptr = &ob1;
        ptr-> show();
        ptr = &ob2;
        ptr-> show();
        
        return 0;
    }
    
    //output:
    //Area is 314
    //Primeter is 62.8
    

    5.抽象类

    如果一个类至少有一个纯虚函数,那么就称该类为抽象类。上述程序中定义的类 circle 就是一个抽象类。

    ①抽象类只能作为其他类的基类来使用,不能建立抽象类的对象。

    ②不允许从具体类派生出抽象类。

    ③抽象类不能用作函数的参数类型、函数的返回类型或显示转换的类型。

    6.虚基类

    虚基类是对多继承来说的。如果一个类有多个直接基类,而这些直接基类又有一个共同的基类,则在最底层的派生类中会保留这个间接的共同基类数据成员的多份同名成员。

    //
    //  VirtualClass.cpp
    //  VirtualClass
    //
    //  Created by 刘一丁 on 2019/8/31.
    //  Copyright © 2019年 LYD. All rights reserved.
    //
    
    
    //file1.cpp
    #include <iostream>
    using namespace std;
    
    class base
    {
    public:
        base()
        {
            a = 5;
            cout << "base a = " << a << endl;
        }
    protected:
        int a;
    };
    
    class base1:public base
    {
    public:
        base1()
        {
            a = a + 10;
            cout << "base1 a = " << a << endl;
        }
    };
    
    class base2:public base
    {
    public:
        base2()
        {
            a = a + 20;
            cout << "base2 a = " << a << endl;
        }
    };
    
    class derived:public base1, public base2
    {
    public:
        derived()
        {
            cout << "base1::a = " << base1::a << endl;  //明确指出调用 base1 的数据成员 a
            cout << "base2::a = " << base2::a << endl;  //明确指出调用 base2 的数据成员 a 
        }
    };
    
    int main()
    {
        derived obj;
        
        return 0;
    }
    
    //output:
    //1.base a = 5
    //2.base1 a = 15
    //3.base a = 5
    //4.base2 a = 25
    //5.base1::a = 15
    //6.base2::a = 25
    
    //注:在访问这些同名成员时,必须在派生类对象名后增加直接基类名
    //使其唯一地标识一个成员,以免产生二义性。

    上述程序中,在定义 derived 对象 obj 时,首先调用 base1 的构造函数,在调用 base2 的构造函数,最后调用 derived 构造函数。在调用 base1 构造函数时又会先调用 base 的构造函数,所以会输出 1-2 语句;在调用 base2 构造函数时又会先调用 base 的构造函数所以输出 3-4 语句。 虽然在类 base1 和 base2 中没有定义数据成员 a ,但是他们在调用基类 base 构造函数时会分别继承基类的数据成员 a。这样就在 base1 和 base2 中同时存在着同名的数据成员 a ,他们都是类 base 成员的拷贝。但是类 base1 和类 base2 中的数据成员 a 分别具有不同的存储单元,可以存放不同的数据(在这里可以这样理解,base1 公有继承了 base ,所以相当于 base1 中也有protected 类型的数据成员 a )。下图显示了其中的层次关系。

    由于在类derived 中同时存在着类 base1 和类base2 的数据成员 a ,因此在 derived 的构造函数中输出 a 的值,必须加上“类名::”,指出是那一个数据成员 a ,否则就会出现二义性。例如

    class derived:public base1, public base2
    {
    public:
        derived()
        { cout << "derived a = " << a << endl; } //错误,二义性。
    };

    要想解决这个问题就需要用到虚基类。即将共同的基类base 声明为虚基类。这就要求从 base 派生新类时,使用关键字 virtual 将类 base 声明为虚基类。声明形式如下:

    class 派生类名:virtual 继承方式 类名
    {
        ...
    }

    用虚基类重写上述代码如下:

    //
    //  VirtualClass.cpp
    //  VirtualClass
    //
    //  Created by 刘一丁 on 2019/8/31.
    //  Copyright © 2019年 LYD. All rights reserved.
    //
    
    
    //file1.cpp
    #include <iostream>
    using namespace std;
    
    class base
    {
    public:
        base()
        {
            a = 5;
            cout << "base a = " << a << endl;
        }
    protected:
        int a;
    };
    
    class base1:virtual public base
    {
    public:
        base1()
        {
            a = a + 10;
            cout << "base1 a = " << a << endl;
        }
    };
    
    class base2:virtual public base
    {
    public:
        base2()
        {
            a = a + 20;
            cout << "base2 a = " << a << endl;
        }
    };
    
    class derived:public base1, public base2
    {
    public:
        derived()
        { cout << "derived a = " << a << endl; }
    };
    
    int main()
    {
        derived obj;
        
        return 0;
    }
    
    //output:
    //base a = 5
    //base1 a = 15
    //base2 a = 35
    //derived a = 35
    
    

    在上述程序中,从类 base 派生出来 base1 和类 base2 时,使用了关键字 virtual,把类 base 声明为类 base1 和 base2 的虚基类。这样,从类 base1 和 base2 派生出的类 derived 只继承基类 base 一次,也就是说,基类 base 的数据成员 a 只保留一份。具体层次关系如下图。

     

     

    展开全文
  • 那么,什么是虚函数呢,我们先来看看微软的解释: 虚函数是指一个中你希望重载的成员函数,当你用一个基类指针或引用指向一个继承对象的时候,你调用一个虚函数,实际调用的是继承的版本。
  • 定义一个形状类(抽象类)以及一个普通成员函数(用来重设形状大小)、两个纯虚成员函数-周长计算函数和面积计算函数,利用该类及其派生类实现圆形、三角形、矩形和梯形等图形的周长和面积的计算;主函数完成基类和...
  • 抽象类和纯虚函数

    2019-09-21 21:41:41
    抽象类的定义就是,含有纯虚函数的类。纯虚函数跟一般的虚函数有很大不同。我们下面来了解下纯虚函数。 一.纯虚函数 即使有的虚函数在基类中不需要做任何工作,我们也要写出一个空的函数体,这时这个函数体没有...
  • 初识虚函数 用virtual关键字说明的函数; 虚函数是实现运行时多态性基础; C++中的虚函数是动态绑定的函数; ...虚函数必须是非静态的成员函数,虚函数经过派生之后,就可以实现运行过程中...虚函数声明只能出现在定...
  • C++ 虚函数虚函数

    2022-05-12 13:49:58
    今天和大家分享的是C++中虚函数虚函数表相关知识
  • 多态性给我们带来了好处:多态使得我们可以通过基类的引用或指针来指明一个对象(包含其派生的...一个函数说明虚函数,表明在继承的中重载这个函数时,当调用这个函数时应当查看以确定调用哪个对象的这个函数。
  • 1、C++定义接口,在java中是要用Interface关键字: 定义接口的时候可以后面=0,相当于=NULL例如: class yl_tcp_client ... //virtual是说明是允许其他继承在此函数基础上进行覆写。 virtual size_t
  • 抽象类、抽象函数/抽象方法详解

    千次阅读 2018-06-13 23:55:23
    抽象类、抽象函数/抽象方法详解 C#抽象类运用 本文提供全流程,中文翻译。 China助力快速理解 抽象类、抽象函数 为新手节省宝贵的时间,避免采坑! 抽象类 —— 修饰词 : abstract 抽象父类中的 抽象函数 是不完整...
  • 基类 在说明其作用前先看一段代码 class A { public: int iValue; }; class B:public A { public: void bPrintf(){cout }; class C:public A { public: void cPrintf(){cout }; class D:...
  • 虚函数抽象类

    千次阅读 2015-02-27 18:23:28
    其实在上述修改后的示例代码里,只要在基类中显式声明了虚函数,那么在之后的派生中就需要用virtual来显式声明了,可以略去,因为系统会根据其是否和基类中虚函数原型完全相同来判断是不是虚函数。因此,上述派生...
  • 主要介绍了C++中虚函数与纯虚函数的用法,是非常重要的概念,需要的朋友可以参考下
  • 抽象函数和虚函数有什么区别? 建议在哪种情况下使用虚拟或抽象? 哪种方法最好?
  • 抽象类 & 接口 一、抽象类: ...另外,抽象类可以派生自一个抽象类可以覆盖基类的抽象方法也可以不覆盖,如果不覆盖,则其派生类必须覆盖它们。 二、接口:  接口是引用类型的,类似于类,和抽象
  • 虚函数:虚函数相当于函数指针,占用四个字节(对于32位),在中虚函数占用四个...不能将友元函数说明为虚函数,但是虚函数可以是另一个的友元。 3.析构函数可以是虚函数,但是构造函数不能是虚函数。#inclu...
  • 主要介绍了深入解析C++编程中的纯虚函数抽象类,是C++入门学习中的基础知识,需要的朋友可以参考下
  • 在面向对象的程序设计中,虚函数,纯虚函数与抽象类一直是工作和求职面试中的重点难点问题。本人在这里对这三者做一个浅显的论述。有不对的地方欢迎各位同行批评指正。(作者原创,转载请注明出处)。提起虚函数,就...
  • 虚函数:被virtual关键字修饰的成员函数,就是实现多态性...指向基类的指针在操作它的多态对象时,会根据不同的对象,调用其相应的函数,这个函数就是虚函数。 纯虚函数:基类只是一个界面函数,其实现由派生
  • C++ 抽象类 一、纯虚函数定义  纯虚函数是在基类中声明的虚函数,它在基类中没有定义,但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0” 二、引入原因: 1、为了方便...
  • c++之抽象类的纯虚析构函数

    千次阅读 2020-01-06 10:51:36
    一、抽象类 1、纯虚函数 形式:virtual 函数原型=0; 定义:在定义一个表达抽象概念的基类时,有时无法给出某些函数的具体实现方法,就可以将这些函数声明为纯虚函数。...但是可以声明指向抽象类的指针...
  • 利用C#语言对面向对象中的虚函数抽象,接口的简单说明
  • 多态性就是允许将子类类型的指针赋值给父类类型的指针,多态是通过虚函数实现的。 多态可以让父类的指针有“多种形态”,这是一种泛型技术。(所谓泛型技术,就是试图使用不变的代码来实现可变的算法)。 2. ...
  • 纯虚函数跟一般的虚函数有什么区别? 纯虚函数: 一个函数只有函数名和形参列表,没有具体实现;语法:virtual double GetArea()=0; 抽象类: 在C++中,含有纯虚拟函数的类称为抽象类,它不能生成对象。抽象类是不...
  • 主要介绍了C++虚函数虚函数表,内容非常详细,思路清晰,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,317
精华内容 15,326
热门标签
关键字:

抽象类可以说明虚函数