精华内容
下载资源
问答
  • virtual关键字
    2022-02-22 11:32:25

    一、序言

            在面向对象的C++语言中,virtual关键字是用来描述虚函数的,虚函数(virtual function)是一个非常重要的概念。

    二、虚函数

    2.1 实例代码

            虚函数是指一个类中希望被重载的成员函数,当使用一个基类指针或引用指向一个继承类对象的时候,调用一个虚函数时, 实际调用的是继承类的版本。
     

    #include <iostream>
    using  namespace std;
    
    class Parent
    {    
     public:
         
         char data[20];
         void Function1();    
         virtual void Function2();   // 这里声明Function2是虚函数
         
     }parent;
     
     void Parent::Function1()
     {//"::"是域操作符,表示Function1函数是Parent类的成员变量
         printf("This is parent,function1\n");
     }
     
     void Parent::Function2()
     {
         printf("This is parent,function2\n");
     }
     
     class Child:public Parent
     {
         void Function1();
         void Function2();
         
     } child;
     
     void Child::Function1()
     {
         printf("This is child,function1\n");
     }
     
     void Child::Function2()
     
     {
         printf("This is child,function2\n");
     }
     
     int main(int argc, char* argv[])
     {
         Parent *p;       // 定义一个基类指针
         if(_getch()=='c')    // 如果输入一个小写字母c    
             p=&child;        // 指向继承类对象
         else    
             p=&parent;       // 否则指向基类对象
         p->Function1();     // 这里在编译时会直接给出Parent::Function1()的入口地址。    
         p->Function2();     // 注意这里,执行的是哪一个Function2?
         return 0;
        
     }

    2.2 编译运行

            编译运行该段代码,输入一个小写字母c,得到下面的结果:

    This is parent,function1
    This is child,function2

    2.3 结果解析

            首先说明:

            "::" 表示 “域操作符” ,比如声明了一个类A,类A里声明了一个成员函数void f(),但没有在类的声明里给出f的定义,那么在类外定义f时, 就要写成void A::f(),表示这个f()函数是类A的成员函数。

            (1)编译运行后,为什么会有第一行的结果呢?

            因为我们是用一个Parent类的指针调用函数Fuction1(),虽然实际上这个指针指向的是Child类的对象,但编译器无法知道这一事实(直到运行的时候,程序才可以根据用户的输入判断出指针指向的对象),它只能按照调用Parent类的函数来理解并编译,这就是静态联编,所以我们看到了第一行的结果。

            (2)那么第二行的结果又是怎么回事呢?

            我们注意到,Function2()函数在基类中被virtual关键字修饰,也就是说,它是一个虚函数。虚函数最关键的特点是“动态联编”,它可以在运行时判断指针指向的对象,并自动调用相应的函数。

             (3)如果我们在运行上面的程序时任意输入一个非c的字符,结果如下:

    This is parent,function1
    This is parent,function2

            请注意看第二行,它的结果出现了变化。程序中仅仅调用了一个Function2()函数,却可以根据用户的输入自动决定到底调用基类中的Function2还是继承类中的Function2,这就是虚函数的作用。

            一定要注意“静态联翩 ”和“ 动态联编 ”的区别;

    附录

    参考:C++中virtual(虚函数)的用法 - 唯一诺 - 博客园

    更多相关内容
  • 1.virtual关键字主要是什么作用?c++中的函数调用默认不适用动态绑定。要触发动态绑定,必须满足两个条件:第一,指定为虚函数;第二,通过基类类型的引用或指针调用。由此可见,virtual主要主要是实现动态绑定。 2....
  • OO思想现在已经在软件开发项目中广泛应用,其中最重要的一个特性就是继承,最近偶简单的复习了下在C#中涉及到继承这个特性时,所需要用到的关键字,其中有一些关键点,特地整理出来,方便大家查阅。 一、在C#中,new...
  • virtual 关键字是面对对象中,用于修饰类中的成员函数的关键字。被 virtual 关键字修饰的函数叫做虚函数。而虚函数本身是实现 C++ 多态的一种方式。 在上图中,我们看到,虚函数属于运行时多态。 那么为什么要使用 ...

    先决条件

    1. 了解 C++ 中的多态这个概念。

    前言

    virtual 关键字是面对对象中,用于修饰类中的成员函数的关键字。被 virtual 关键字修饰的函数叫做虚函数。而虚函数本身是实现 C++ 多态的一种方式。
    在这里插入图片描述
    在上图中,我们看到,虚函数属于运行时多态。

    那么为什么要使用 virtual 关键字呢?它的作用是什么呢?

    演示示例

    下面先来看看 virtual 关键字的使用。

    在这个示例中,我们演示不使用 virtual 关键字时会发生的问题。

    #include <iostream>
    using namespace std;
    
    class Human
    {
    public:
        void YourRace()
        {
            cout << "我是人类" << endl;
        }
    };
    
    class Aisan : public Human
    {
    public:
        void YourRace()
        {
            cout << "我是黄种人(亚洲人)" << endl;
        }
    };
    
    int main()
    {
        Human *h;
        Aisan a;
        h = &a;
        h->YourRace(); // 我是人类
    }
    

    上面的代码描述的是,*h 为基类的一个指针,它被指向了 Human 的派生类的一个对象 a(即 h = &a ;)。

    在 C++ 中,基类指针可以指向派生类的对象,但是默认情况下,基类指针不能访问派生类的成员。所以我们看到当指向 a 的基类指针调用 YourRace 函数时,它实际调用的是基类的函数,而不是我们期望的派生类的 YourRace 函数。

    那么如果要解决这个问题,即想要调用派生类的 YourRace 函数,我们只需要在基类的 YourRace 函数前面增加 virtual 关键字即可,它的语法是:virtual void YourRace(){...};

    #include <iostream>
    using namespace std;
    
    class Human
    {
    public:
    	// 在基类的同名函数中加上 virtual 关键字
        virtual void YourRace()
        {
            cout << "我是人类" << endl;
        }
    };
    
    class Aisan : public Human
    {
    public:
        void YourRace()
        {
            cout << "我是黄种人(亚洲人)" << endl;
        }
    };
    
    int main()
    {
        Human *h;
        Aisan a;
        h = &a;
        h->YourRace(); // 我是黄种人(亚洲人)
    }
    

    可以看到,本段代码仅仅是新增了一个 virtual 关键字,就实现了调用派生类成员函数的功能。

    virtual 关键字的作用

    可以看到,增加了 virtual 关键字后,实际上,编译器是在运行时才确定对象的类型,执行动态链接,然后绑定函数调用,所以这又叫动态绑定。

    比如在上面的第二段代码中,h 实际指向的对象是 aa 的类型是 Aisan,所以最终调用的是 Aisan 类的 YourRace 函数。

    在基类中使用 virtual 关键字,表明基类要求派生类重写这个函数。当使用指针或者应用调用虚函数时,调用被动态绑定到运行时才发生,也就是根据被绑定的对象的类型不同,执行具体的版本,就像上面所展示的那样。

    【注】非虚函数的解析发生在编译过程。虚函数的解析发生在运行时。

    虚函数的规则

    1. 虚函数是基类的成员函数(只能出现在类内),其派生的同名函数用于重写覆盖(override)其内容。
    2. virtual 不能修饰静态成员。
    3. virtual 不能修饰构造函数,但可以修饰析构函数,并且用于多态目的的基类通常都应该定义一个 virtual 的析构函数。(关于这一点,你可以查看《Effective C++》07 条款,获得更详细的内容。
    4. 派生类继承的基类里面的虚函数,在派生类中隐式的,也是虚函数。

    参考与拓展

    1. C++ virtual function【javatpoint】
    2. Virtual Function in C++【geeksforgeeks】
    3. 为什么静态static成员函数不能成为virtual虚函数
    4. 析构函数可以为virtual,构造函数则不能。原因?
    5. Why Destructors in C++ can be virtual but constructors cannot be virtual?
    6. 为什么要用基类指针指向派生类对象?
    7. 《Primer C++》
    8. 区别:编译时与运行时(Combile-time Vs Runtime)
    9. Virtual Destructor:为什么析构函数可以是,也最好是 virutal 的。
    10. override Keyword in C++ :virtual 与 override 搭配使用。
    11. 《Effective C++》
    展开全文
  • 以下从多个角度来深入理解virtual关键字。 1.virtual关键字主要是什么作用? c++中的函数调用默认不适用动态绑定。要触发动态绑定,必须满足两个条件:第一,指定为虚函数;第二,通过基类类型的引用或指针调用...

    对virtual关键的理解需要结合其应用场景来分析。以下从多个角度来深入理解virtual关键字。

    1.virtual关键字主要是什么作用?

    c++中的函数调用默认不适用动态绑定。要触发动态绑定,必须满足两个条件:第一,指定为虚函数;第二,通过基类类型的引用或指针调用(多态产生的条件)。
    由此可见,virtual主要主要是实现动态绑定。

    2.哪些情况下可以使用virtual关键字?

    virtual可用来定义类函数和应用到虚继承(一个是多态应用到函数,一个虚继承应用到类)。

    友元函数 构造函数 static静态函数 不能用virtual关键字修饰(请思考为什么?—静态链编);
    普通成员函数 和析构函数 可以用virtual关键字修饰;

    3.virtual函数的效果

    class GrandFather
    { public:
     GrandFather() {}
     virtual void fun()
     {  cout << "GrandFather call function!" << endl;
      }
    };
    
    
    class Father : public GrandFather
    { public:
      Father() {}
      void fun()
      {  cout << "Father call function!" << endl;
      }
    };
    
    class Son : public Father
    {  public:
       Son() {}
       void fun()
      {    cout << "Son call function!" << endl;
      }
    };
    
    void print(GrandFather* father)
    { father->fun();
    }
    
    int _t main(int argc, _TCHAR* argv[])
    { Father * pfather = new Son;
            pfather->fun();
            GrandFather * pgfather = new Father;
            print(pgfather);
     return 0;
    }
    

    输出为 Son call function

       Father call function
    

    这就是实现多态的效果!

    4.virtual的继承性

    只要基函数定义了virtual,继承类的该函数也就具有virtual属性
    即 GrandFather Father Son同时定义virtual void fun()与GrandFather一个定义virtual void fun效果是一样的

    5.虚析构函数

    class GrandFather
    { public:
      GrandFather() {}
      virtual void fun()
     {  cout << "GrandFather call function!" << endl;
     }
    
    
     ~GrandFather()
     { cout << "GrandFather destruction!" << endl;
     }
    };
    
    class Father : public GrandFather
    { public:
      Father() {}
      void fun()
      {   cout << "Father call function!" << endl;
      }
    
     ~Father()
     { cout << "Father destruction!" << endl;
     }
    };
    
    class Son : public Father
    { public:
      Son() {}
      void fun()
     { cout << "Son call function!" << endl;
     }
    
      ~Son()
     { cout << "Son destruction!" << endl;
      }
    };
    
    void print(GrandFather* p)
    { p->fun();
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    { Father * pfather = new Son;
      delete pfather;
      return 0;
    }
    

    以上代码输出:
    Father destruction! GrandFather destruction!
    执行了Son的构造函数,没执行Son的析构函数,故把GrandFather的析构函数设置为virtual
    则输出:
    Son destruction! Father Destruction! GrandFather destruction!

    6. 纯虚函数

    纯虚函数定义如下:

    class GrandFather
    { public:
      GrandFather() {}
      virtual void fun() = 0
     { cout << "GrandFather call function!" << endl;
     }
    
    
     virtual ~GrandFather()
     {
      cout << "GrandFather destruction!" << endl;
     }
    };
    

    纯虚函数为后代类提供可覆盖的接口,但这个类中的版本决不会调用。
    含有(或继续)一个或多个纯虚函数的类是抽象基类,抽象基类不能实例化!
    继承类只有重写这个接口才能被实例化

    7.虚继承

    虚继承主要解决交叉继承带来的问题。这里给出一片参考文章c++虚继承。
    给一个例子如下

    class GrandFather
    { public:
      GrandFather() {}
      void fun()
     { cout << "GrandFather call function!" << endl;
     }
    
    
     virtual ~GrandFather()
     { cout << "GrandFather destruction!" << endl;
     }
    };
    
    class Father1 : public GrandFather
    { public:
      Father1() {}
      void fun()
     { cout << "Father call function!" << endl;
     }
    };
    
    class Father2 : public GrandFather
    { public:
      Father2() {}
      void fun()
     { cout << "Father call function!" << endl;
     }
    
    };
    
    class Son : public Father1, public Father2
    { public:
      Son() {}
     //void fun()
     //{
     // cout << "Son call function!" << endl;
     //}
    };
    
    void print(GrandFather* p)
    { p->fun();
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    { Son* son = new Son;
      son->fun();
      return 0;
    }
    

    编译时会提示报错对fun的访问不明确
    如果Father1和Father2都用虚继承继承GrandFather类则可以解决这个问题

    8. 构造函数和析构函数中的虚函数

    如果在构造函数或析构函数中调用虚函数,则运行的是为构造函数或析构函数自身类型定义的版本

    9.虚函数的实现机制

    关于虚函数的实现机制,我们以后在介绍。

    10.小结

    关于virtual关键字的用法总结如上,有错误或者总结不到位的情况请能帮本人指出!

    11.例子

    class classA
    { public:
      classA()
     { clear();
     }
     virtual ~classA()
     {
      }
     void clear()
     {  memset(this , 0 , sizeof(*this));
     }
     virtual void func()
     {  printf("func\n");
     }
    };
    
    
    class classB : public classA
    {
    };
    
    int main(void)
    {
     classA oa;
     classB ob;
     classA * pa0 = &oa;
     classA * pa1 = &ob;
     classB * pb = &ob;
     oa.func(); // 1
     ob.func(); // 2
     pa0->func(); // 3
     pa1->func(); // 4
     pb->func(); // 5
     return 0;
    }
    

    补充一个例子,这个程序输出依次是

    func
    func
    出错
    func
    func
    

    谈谈我的理解,当

    classA oa;
    oa.func();
    

    不存在动态调用的过程,所以func虽然是虚函数,但是函数调用不通过虚表访问,所以即使

    memset(this , 0 , sizeof(*this));

    找不到虚表地址也没有关系
    在执行classB ob;的时候,注意memset的是classA的地址,所有ob的虚表是存在的
    即是如下,通过指针或引用(动态绑定)访问oa的func函数(需要从虚表访问),会出错
    访问ob的func和函数,无论静态访问还是动态访问,都不会出错

    当把classB的代码改成如下时

    class classB : public classA
    classB()
     {  clear();
     }
     virtual ~classB()
     {
     }
     void clear()
     {  memset(this , 0 , sizeof(*this));
     }
     输出为
    
    func
    func
    出错
    出错
    出错
    
    展开全文
  • C# virtual关键字详解

    2021-01-19 14:11:14
    virtual 关键字能修饰方法、属性、索引器以及事件等,用到父类的成员中。使用 virtual 关键字修饰属性和方法的语法形式如下。//修饰属性public virtual 数据类型 属性名{get; set; }//修饰方法访问修饰...

    C# virtual 是虚拟的含义,在 C# 语言中,默认情况下类中的成员都是非虚拟的,通常将类中的成员定义成虚拟的,表示这些成员将会在继承后重写其中的内容。

    virtual 关键字能修饰方法、属性、索引器以及事件等,用到父类的成员中。

    使用 virtual 关键字修饰属性和方法的语法形式如下。

    //修饰属性

    public  virtual  数据类型  属性名{get; set; }

    //修饰方法

    访问修饰符  virtual  返回值类型方法名

    {

    语句块;

    }

    需要注意的是,virtual 关键字不能修饰使用 static 修饰的成员。

    此外,virtual 关键字既可以添加到访问修饰符的后面,也可以添加到访问修饰符的前面,但实际应用中习惯将该关键字放到访问修饰符的后面。

    子类继承父类后能重写父类中的成员,重写的关键字是 override。

    所谓重写是指子类和父类的成员定义一致,仅在子类中增加了 override 关键字修饰成员。

    例如在父类中有一个求长方形面积的方法,方法定义如下。

    publie int Area(int x, int y)

    {

    return x * y

    }

    在子类中重写该方法的代码如下。

    public override int Area(int x,int y)

    {

    语句块;

    return  整数类型的值;

    }

    在子类中重写父类中的方法后能改变方法体中的内容,但是方法的定义不能改变。

    【实例 1】将上一节《C# base》中定义的 Person 类中的 Print 方法更改为虚拟的方法,分别用 Student 类和 Teacher 类继承 Person 类,并重写 Print 方法,打印出学生信息和教师信息。

    为了减少重复的代码,在每个类中省略了属性部分的定义内容,仅保留 Print 方法部分的内容,实现的代码如下。

    class Person

    {

    public virtual void Print()

    {

    Console.WriteLine("编号:"+ Id);

    Console.WriteLine("姓名:"+ Name);

    Console.WriteLine("性别:"+ Sex);

    Console.WriteLine("身份证号:"+ Cardid);

    Console.WriteLine("联系方式:"+ Tel);

    }

    }

    class Student:Person

    {

    public override void Print()

    {

    Console.WriteLine("编号:"+ Id);

    Console.WriteLine("姓名:"+ Name);

    Console.WriteLine("性别:"+ Sex);

    Console.WriteLine("身份证号:"+ Cardid);

    Console.WriteLine("联系方式:"+ Tel);

    Console.WriteLine("专业:"+ Major);

    Console.WriteLine("年级:"+ Grade);

    }

    }

    class Teacher:Person

    {

    public override void Print()

    {

    Console.WriteLine("编号:"+ Id);

    Console.WriteLine("姓名:"+ Name);

    Console.WriteLine("性别:"+ Sex);

    Console.WriteLine("身份证号:"+ Cardid);

    Console.WriteLine("联系方式:"+ Tel);

    Console.WriteLine("专业:"+ Major);

    Console.WriteLine("年级:"+ Grade);

    }

    }

    通过上面的代码即可完成对 Person 类中 Print 方法的重写,在重写后的 Print 方法中能直接调用在 Person 类中定义的成员。

    但读者会发现在 Person 类的 Print 中已经对 Person 中的相关属性编写了输出操作的代码,而每一个子类中又重复地编写了代码,造成代码的冗余,也没有体现出代码重用的特点。

    如果能在重写父类方法的同时直接使用父类中已经编写过的内容就会方便很多。

    在重写 Print 方法后仍然需要使用 base 关键字调用父类中的 Print 方法执行相应的操作。

    【实例 2】改写实例 1 中的 Student 和 Teacher 类中重写的 Print 方法,使用 base 关键字调用父类中的 Print 方法。

    根据题目要求,更改后的代码如下。

    class Student:Person

    {

    public override void Print()

    {

    base.Print ();

    Console.WriteLine("专业:"+ Major);

    Console.WriteLine("年级:"+ Grade);

    }

    }

    class Teacher:Person

    {

    public override void Print()

    {

    base.Print ();

    Console.WriteLine("专业:"+ Major);

    Console.WriteLine("年级:"+ Grade);

    }

    }

    从上面的代码可以看出继承给程序带来的好处,不仅减少了代码的冗余,还增强了程序的可读性。

    方法隐藏和重写方法有区别吗?这是很多初学者常问的问题。观察以下代码,思考结果会是什么?

    class Program

    {

    static void Main(string[] args)

    {

    A a1 = new B();

    a1.Print();

    A a2 = new C();

    a2.Print();

    }

    }

    class A

    {

    public virtual void Print()

    {

    Console.WriteLine("A");

    }

    }

    class B :A

    {

    public new void Print()

    {

    Console.WriteLine("B");

    }

    }

    class C :A

    {

    public override void Print()

    {

    Console.WriteLine("C");

    }

    }

    执行上面的代码,效果如下图所示。

    c9c10f90a7778028be3e48f11bd69e4c.gif

    从上面的执行效果可以看出,使用方法隐藏的方法调用的结果是父类 A 中 Print 方法中的内容,而使用方法重写的方法调用的结果是子类 C 中 Print 方法中的内容。

    因此方法隐藏相当于在子类中定义新方法,而方法重写则是重新定义父类中方法的内容。

    从上面的代码也可以看出,在“A a1=new B()”语句中 A 类是父类、B 类是子类,相当于将子类转换成父类,即隐式转换。

    如果需要将父类转换成子类,则需要强制转换,并且在强制转换前需要先将所需的子类转换成父类,示例代码如下。

    A a2=new C();

    C c=(C) a2;

    c.Print();

    在上面的实例中,a2 是父类对象,然后将其强制转换成 C 类对象。

    Object 类中的 ToString 方法能被类重写,并返回所需的字符串,通常将其用到类中返回类中属性的值。

    在 Student 类中添加重写的 ToString 方法,代码如下。

    class Student

    {

    public string Major{ get; set;}

    public string Grade{ get; set;}

    public void Print()

    {

    Console.WriteLine("专业:"+ Major);

    Console.WriteLine("年级:"+ Grade);

    }

    public override string ToString()

    {

    return Major+","+Grade;

    }

    }

    这样,在调用 Student 类中的 ToString 方法时即可获取专业和年级的值。

    此外,除了 ToString 方法,在类中也可以重写 Equals 方法、GetHashCode 方法。

    展开全文
  • MySQL5.7 virtual关键字

    2021-01-19 14:11:22
    本机调试保存数据时报错: Hibernate: /* insert ...果然搜索到virtual是MySQL5.7的新关键字。详见:http://blog.itpub.net/30633755/viewspace-2127708/ 解决方法:修改字段名称virtual改成is_virtual
  • 关于virtual关键字的用法总结如下,有错误或者总结不到位的情况请能帮本人指出,非常感谢! Virtual是C++ OO机制中很重要的一个关键字。只要是学过C++的人都知...
  • @C++面向对象之virtual(转载) ...先从virtual说起 面向对象的三大特征,封装,继承...C++中的virtual关键字修饰方法 约等于 Java中abstract关键字修饰方法。 virtual,望文生义。虚拟的意思。它是用来修饰一个方法的,当
  • systemverilog:virtual 关键字的用法

    千次阅读 2020-04-24 11:38:10
    我在csdn上查询了systemverilog中关于virtual关键字的用法,发现了这么一句话: “***virtual function/task: 用于OOP思想的继承使用。当定义了virtual时,在子类中调用某function/task,会先查找在子类中是否定义...
  • 初识多态,剖析virtual关键字

    多人点赞 热门讨论 2022-06-24 08:32:21
    父类中的eat前加了virtual关键字,那么eat函数就被叫做虚函数,这些就满足了多态的条件。此外,doEat函数的参数列表是父类的引用,那么也就满足了多态使用的父类引用或指针指向子类对象。 如果doEat不加引用,那么...
  • 代码如下: class A { public virtual void Func() // 注意virtual,表明这是一个虚拟函数 { Console.WriteLine(“Func In A”); } } class B : A // 注意B是从A类继承,所以A是父类,B是子类 { public override void ...
  • virtual关键字能够修饰方法、属性、索引器以及事件,用到父类的成员中 <!--more--> 二 virtual 语法形式 2.1 语法形式 2.1.1 使用virtual关键字修饰属性语法形式 <span style="color:#333333">/...
  • virtual关键字在子类

    2019-09-06 17:37:44
    virtual关键字在父类 析构函数的virtual在子类 间接调用虚函数 完整代码 #include using namespace std; class father { public: void f() { cout()"; } }; class son : public father { public: ...
  • C++: Virtual关键字的几种用法

    千次阅读 2019-11-06 09:52:10
    c++中的关键字virtual”主要用在两个方面:虚函数与虚基类。下面将分别从这两个方面对virtual进行介绍。1.虚函数 虚函数源于c++中的类继承,是多态的一种。在c++中,一个基类的指针或者引用可以指向或者引用派生...
  • virtual关键字--C++Virtual 是C++OO机制中很重要的一个关键字。只要是学过C++的人都知道在类Base中加了Virtual关键字的函数就是虚拟函数(例如函数print),于是在Base的派生类Derived中就可以通过重写虚拟函数来实现...
  • C++虚函数(virtual关键字)

    千次阅读 2020-03-25 10:30:15
    当函数被virtual关键字修饰时,该函数被称为虚函数,虚函数是指一个类中你希望重载的成员函数,当你用一个基类指针或引用指向一个继承类对象的时候,你调用一个虚函数,实际调用的是继承类的版本。虚函数最关键的...
  • 在验证工作中经常使用"virtual"关键字,下面列举该关键字应用场景。 主要应用场景在virtual class,virtual interface 以及 virtual task/function。 OOP三大特性(封装,继承,多态)中的多态在SystemVerilog中...
  • 基础理解和demo 普通的继承 #include class Parent { public: void print() { std::cout << "Parent" << std::endl; } }; class Child : Parent { ...但是如果是 “父类的指针指向子类
  • c++之virtual关键字

    千次阅读 2019-04-12 12:43:09
    在c++中,基类必须将它的两种成员函数区分开来, (1)一种是基类希望其派生类进行覆盖(override)的函数。...基类通过在其成员函数的声明语句之前加关键字virtual使得该函数执行动态绑定。 任何...
  • Systemverilog 的 virtual 关键字的用法

    千次阅读 2018-08-10 14:39:03
    virtual interface virtual classs virtual task virtual function 2. 简介 由virtual所声明的内容可理解为一个模板,后续的例化和引用可在这个模板上进行增加或修改,这样就呈现出特定的内容或特性。不同的...
  • virtual关键字的作用

    千次阅读 2016-04-07 11:23:19
    1. 在派生类中重新定义基类的方法当需要在派生类中重新定义基类的方法时,应在基类方法... 方法重写注意:使用不使用关键字virtual如果使用了virtual关键字,程序将根据引用或指针指向的 对 象 类 型 来选择方法,否则
  • virtual关键字在父类

    2019-09-06 17:34:06
    此例是virtual关键字的基本用法,用于与后面其它的测试场景做对比。 其它测试 virtual关键字在子类 析构函数的virtual在子类 间接调用虚函数 完整代码 #include using namespace std; class father { ...
  •   所以,没有virtual关键字就像死刑立即执行,有virtual关键字更像是缓期执行,让你有更充足的准备(指针实际指向的类对象)去判断到底该调用谁?   最后贴上完整的代码: #include < iostream > using ...
  • c++Virtual关键字

    2016-06-26 15:04:05
    c++也是用到面向对象的思想,因此创建函数时,当子类重写了父类函数,则默认会被父类函数方法覆盖,无论子类或父类对象调用,都使用父类方法,因此就会涉及到关键字Virtual。 因此,在父类同名函数前增加关键字...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 99,531
精华内容 39,812
关键字:

virtual关键字

友情链接: test2.rar