Why do we need virtual functions in C

Question

I m learning C   and I m just getting into virtual functions   From what I ve read  in the book and online   virtual functions are functions in the base class that you can override in derived classes   But earlier in the book  when learning about basic inheritance  I was able to override base functions in derived classes without using virtual   So what am I missing here  I know there is more to virtual functions  and it seems to be important so I want to be clear on what it is exactly  I just can t find a straight answer online

User · Answer

If the base class is Base  and a derived class is Der  you can have a Base  p pointer which actually points to an instance of Der   When you call p- gt foo     if foo is not virtual  then Base s version of it executes  ignoring the fact that p actually points to a Der   If foo is virtual  p- gt foo   executes the  leafmost  override of foo  fully taking into account the actual class of the pointed-to item   So the difference between virtual and non-virtual is actually pretty crucial  the former allows runtime polymorphism  the core concept of OO programming  while the latter does not

User · Answer

The keyword virtual tells the compiler it should not perform early binding  Instead  it should automatically install all the mechanisms necessary to perform late binding  To accomplish this  the typical compiler1 creates a single table  called the VTABLE  for each class that contains virtual functions The compiler places the addresses of the virtual functions for that particular class in the VTABLE  In each class with virtual functions it secretly places a pointer  called the vpointer  abbreviated as VPTR   which points to the VTABLE for that object  When you make a virtual function call through a base-class pointer the compiler quietly inserts code to fetch the VPTR and look up the function address in the VTABLE  thus calling the correct function and causing late binding to take place   More details in this link http   cplusplusinterviews blogspot sg 2015 04 virtual-mechanism html

User · Answer

Why do we need Virtual Methods in C      Quick Answer    It provides us with one of the needed  ingredients 1 for object oriented programming     In Bjarne Stroustrup C   Programming  Principles and Practice   14 3       The virtual function provides the ability to define a function in a base class and have a function of the same name and type in a derived class called when a user calls the base class function  That is often called run-time polymorphism  dynamic dispatch  or run-time dispatch because the function called is determined at run time based on the type of the object used     It is the fastest more efficient implementation if you need a virtual function call 2       To handle a virtual call  one needs one or more pieces of data related to the derived object 3  The way that is usually done is to add the address of table of functions  This table is usually referred to as virtual table or virtual function table and its address is often called the virtual pointer  Each virtual function gets a slot in the virtual table  Depending of the caller s object  derived  type  the virtual function  in its turn  invokes the respective override         1 The use of inheritance  run-time polymorphism  and encapsulation is the most common definition of object-oriented programming   2  You can t code functionality to be any faster or to use less memory using other language features to select among alternatives at run time  Bjarne Stroustrup C   Programming  Principles and Practice  14 3 1    3  Something to tell which function is really invoked when we call the base class containing the virtual function

User · Answer

The problem with explanations to virtual functions  is that they don t explain how it is used in practice  and how it helps with maintainability  I ve created a virtual function tutorial which people have already found very useful  Plus  it s based on a battlefield premise  which makes it a bit more exciting  https   nrecursions blogspot com 2015 06 so-why-do-we-need-virtual-functions html     Consider this battlefield application       include  iostream     This class is created by Gun1 s company class Gun1  public  void fire    std  cout lt  lt  gun1 firing now n        This class is created by Gun2 s company class Gun2  public  void shoot    std  cout lt  lt  gun2 shooting now n         We create an abstract class to interface with WeaponController class WeaponsInterface    public   virtual void shootTarget     0        A wrapper class to encapsulate Gun1 s shooting function class WeaponGun1   public WeaponsInterface    private   Gun1  g    public   WeaponGun1    g new Gun1         WeaponGun1     delete g    virtual void shootTarget     g- gt fire            A wrapper class to encapsulate Gun2 s shooting function class WeaponGun2   public WeaponsInterface    private   Gun2  g    public   WeaponGun2    g new Gun2         WeaponGun2     delete g    virtual void shootTarget     g- gt shoot          class WeaponController    private   WeaponsInterface  w   WeaponGun1  g1   WeaponGun2  g2   public   WeaponController    g1   new WeaponGun1    g2   new WeaponGun2    w   g1     WeaponController    delete g1  delete g2    void shootTarget     w- gt shootTarget      void changeGunTo int gunNumber     Virtual functions makes it easy to change guns dynamically    switch gunNumber         case 1  w   g1  break       case 2  w   g2  break               class BattlefieldSoftware    private   WeaponController  wc   public   BattlefieldSoftware     wc new WeaponController         BattlefieldSoftware     delete wc      void shootTarget     wc- gt shootTarget       void changeGunTo int gunNumber   wc- gt changeGunTo gunNumber          int main      BattlefieldSoftware  bf   new BattlefieldSoftware     bf- gt shootTarget     for int i   2  i  gt  0  i--         bf- gt changeGunTo i        bf- gt shootTarget        delete bf      I encourage you to first read the post on the blog to get the gist of why the wrapper classes were created     As visible in the image  there are various guns missiles that can be connected to a battlefield software  and commands can be issued to those weapons  to fire or re-calibrate etc  The challenge here is to be able to change replace the guns missiles without having to make changes to the blue battlefield software  and to be able to switch between weapons during runtime  without having to make changes in the code and re-compile     The code above shows how the problem is solved  and how virtual functions with well-designed wrapper classes can encapsulate functions and help in assigning derived class pointers during runtime  The creation of class WeaponGun1 ensures that you ve completely separated the handling of Gun1 into the class  Whatever changes you do to Gun1  you ll only have to make changes in WeaponGun1  and have the confidence that no other class is affected   Because of WeaponsInterface class  you can now assign any derived class to the base class pointer WeaponsInterface and because it s functions are virtual  when you call WeaponsInterface s shootTarget  the derived class shootTarget gets invoked   Best part is  you can change guns during runtime  w g1 and w g2   This is the main advantage of virtual functions and this is why we need virtual functions   So no more necessity to comment out code in various places when changing guns  It s now a simple and clean procedure  and adding more gun classes is also easier because we just have to create a new WeaponGun3 or WeaponGun4 class and we can be confident that it won t mess up BattlefieldSoftware s code or WeaponGun1 WeaponGun2 s code

User · Answer

You have to distinguish between overriding and overloading  Without the virtual keyword you only overload a method of a base class  This means nothing but hiding  Let s say you have a base class Base and a derived class Specialized which both implement void foo    Now you have a pointer to Base pointing to an instance of Specialized  When you call foo   on it you can observe the difference that virtual makes  If the method is virtual  the implementation of Specialized will be used  if it is missing  the version from Base will be chosen  It is best practice to never overload methods from a base class  Making a method non-virtual is the way of its author to tell you that its extension in subclasses is not intended

User · Answer

Here is a merged version of the C   code for the first two answers    include         lt iostream gt   include         lt string gt   using   namespace       std   class   Animal           public   ifdef  VIRTUAL                 virtual string  says            return             else                 string  says            return             endif     class   Dog     public Animal           public                  string  says            return   woof         string  func Animal  a            return  a- gt says       int     main             Animal   a   new Animal            Dog      d   new Dog            Animal   ad   d           cout  lt  lt   Animal a says t t   lt  lt  a- gt says    lt  lt  endl          cout  lt  lt   Dog d says t t   lt  lt  d- gt says    lt  lt  endl          cout  lt  lt   Animal dog ad says t   lt  lt  ad- gt says    lt  lt  endl           cout  lt  lt   func a    t t   lt  lt       func a   lt  lt       endl          cout  lt  lt   func d    t t   lt  lt       func d   lt  lt       endl          cout  lt  lt   func ad   t t   lt  lt       func ad  lt  lt       endl      Two different results are   Without  define virtual  it binds at compile time  Animal  ad and func Animal    all point to the Animal s says   method     g   virtual cpp -o virtual     virtual  Animal a says          Dog d says      woof Animal dog ad says     func a             func d             func ad              With  define virtual  it binds at run time  Dog  d  Animal  ad and func Animal    point refer to the Dog s says   method as Dog is their object type  Unless  Dog s says    woof   method is not defined  it will be the one searched first in the class tree  i e  derived classes may override methods of their base classes  Animal s says        g   virtual cpp -D VIRTUAL -o virtual     virtual  Animal a says          Dog d says      woof Animal dog ad says  woof func a             func d          woof func ad         woof   It is interesting to note that all class attributes  data and methods  in Python are effectively virtual  Since all objects are dynamically created at runtime  there is no type declaration or a need for keyword virtual  Below is Python s version of code   class   Animal          def     says self                   return        class   Dog Animal           def     says self                   return   woof   def     func a           return  a says    if        name         main              a   Animal           d   Dog           ad   d          dynamic typing by assignment          print  Animal a says t t    format a says             print  Dog d says t t    format d says             print  Animal dog ad says t    format ad says              print  func a    t t    format func a            print  func d    t t    format func d            print  func ad   t t    format func ad      The output is   Animal a says          Dog d says      woof Animal dog ad says  woof func a             func d          woof func ad         woof   which is identical to C   s virtual define  Note that d and ad are two different pointer variables referring pointing to the same Dog instance  The expression  ad is d  returns True and their values are the same  lt main Dog object at 0xb79f72cc

User · Answer

Here is how I understood not just what virtual functions are  but why they re required   Let s say you have these two classes   class Animal       public          void eat     std  cout  lt  lt   I m eating generic food          class Cat   public Animal       public          void eat     std  cout  lt  lt   I m eating a rat           In your main function   Animal  animal   new Animal  Cat  cat   new Cat   animal- gt eat       Outputs   I m eating generic food   cat- gt eat          Outputs   I m eating a rat     So far so good  right  Animals eat generic food  cats eat rats  all without virtual   Let s change it a little now so that eat   is called via an intermediate function  a trivial function just for this example       This can go at the top of the main cpp file void func Animal  xyz    xyz- gt eat        Now our main function is   Animal  animal   new Animal  Cat  cat   new Cat   func animal      Outputs   I m eating generic food   func cat         Outputs   I m eating generic food     Uh oh    we passed a Cat into func    but it won t eat rats  Should you overload func   so it takes a Cat   If you have to derive more animals from Animal they would all need their own func     The solution is to make eat   from the Animal class a virtual function   class Animal       public          virtual void eat     std  cout  lt  lt   I m eating generic food          class Cat   public Animal       public          void eat     std  cout  lt  lt   I m eating a rat           Main   func animal      Outputs   I m eating generic food   func cat         Outputs   I m eating a rat     Done

User · Answer

The virtual keyword forces the compiler to pick the method implementation defined in the object s class rather than in the pointer s class     Shape  shape   new Triangle     cout  lt  lt  shape- gt getName      In the above example  Shape  getName will be called by default  unless the getName   is defined as virtual in the Base class Shape  This forces the compiler to look for the getName   implementation in the Triangle class rather than in the Shape class    The virtual table is the mechanism in which the compiler keeps track of the various virtual-method implementations of the subclasses  This is also called dynamic dispatch  and there is some overhead associated with it    Finally  why is virtual even needed in C    why not make it the default behavior like in Java     C   is based on the principles of  Zero Overhead  and  Pay for what you use   So it doesn t try to perform dynamic dispatch for you  unless you need it   To provide more control to the interface  By making a function non-virtual  the interface abstract class can control the behavior in all its implementations

User · Answer

The bottom line is that virtual functions make life easier  Let s use some of M Perry s ideas and describe what would happen if we didn t have virtual functions and instead only could use member-function pointers  We have  in the normal estimation without virtual functions    class base    public   void helloWorld     std  cout  lt  lt   Hello World             class derived  public base    public   void helloWorld     std  cout  lt  lt   Greetings World            int main            base hwOne        derived hwTwo   new derived          base- gt helloWorld      prints  Hello World         derived- gt helloWorld      prints  Hello World     Ok  so that is what we know  Now let s try to do it with member-function pointers     include  lt iostream gt   using namespace std    class base    public   void helloWorld     std  cout  lt  lt   Hello World            class derived   public base    public   void displayHWDerived void derived   hwbase        this- gt  hwbase        void derived   hwBase      void helloWorld     std  cout  lt  lt   Greetings World            int main       base  b   new base      Create base object  b- gt helloWorld       Hello World   void derived   hwBase       amp derived  helloWorld    create derived member   function pointer to base function  derived  d   new derived      Create derived object    d- gt displayHWDerived hwBase     Greetings World    char ch   cin  gt  gt  ch       While we can do some things with member-function pointers  they aren t as flexible as virtual functions  It is tricky to use a member-function pointer in a class  the member-function pointer almost  at least in my practice  always must be called in the main function or from within a member function as in the above example   On the other hand  virtual functions  while they might have some function-pointer overhead  do simplify things dramatically   EDIT  There is another method which is similar by eddietree  c   virtual function vs member function pointer  performance comparison

User · Answer

Virtual Functions are used to support Runtime Polymorphism   That is  virtual keyword tells the compiler not to make the decision  of function binding  at compile time  rather postpone it for runtime     You can make a function virtual by preceding the keyword virtual in its base class declaration  For example    class Base        virtual void func        When a Base Class has a virtual member function  any class that inherits from the Base Class can redefine the function with exactly the same prototype i e  only functionality can be redefined  not the interface of the function     class Derive   public Base        void func        A Base class pointer can be used to point to Base class object as well as a Derived class object   When the virtual function is called by using a Base class pointer  the compiler decides at run-time which version of the function - i e  the Base class version or the overridden Derived class version - is to be called  This is called Runtime Polymorphism

User · Answer

Here is complete example that illustrates why virtual method is used     include  lt iostream gt   using namespace std   class Basic       public      virtual void Test1                 cout  lt  lt   Test1 from Basic    lt  lt  endl            virtual  Basic         class VariantA   public Basic       public      void Test1                 cout  lt  lt   Test1 from VariantA    lt  lt  endl           class VariantB   public Basic       public      void Test1                 cout  lt  lt   Test1 from VariantB    lt  lt  endl            int main         Basic  object      VariantA  vobjectA   new VariantA        VariantB  vobjectB   new VariantB         object  Basic    vobjectA      object- gt Test1         object  Basic    vobjectB      object- gt Test1         delete vobjectA      delete vobjectB      return 0

User · Answer

Virtual methods are used in interface design   For example in Windows there is an interface called IUnknown like below   interface IUnknown     virtual HRESULT QueryInterface  REFIID riid  void   ppvObject    0    virtual ULONG   AddRef      0    virtual ULONG   Release      0       These methods are left to the interface user to implement   They are essential for the creation and destruction of certain objects that must inherit IUnknown   In this case the run-time is aware of the three methods and expects them to be implemented when it calls them   So in a sense they act as a contract between the object itself and whatever uses that object

User · Answer

Need for Virtual Function explained  Easy to understand    include lt iostream gt   using namespace std   class A  public           void show            cout  lt  lt    Hello from Class A             class B  public A  public       void show            cout  lt  lt    Hello from Class B              int main         A  a1   new B     Create a base class pointer and assign address of derived object      a1- gt show         Output will be   Hello from Class A    But with virtual function    include lt iostream gt   using namespace std   class A  public      virtual void show            cout  lt  lt    Hello from Class A             class B  public A  public      virtual void show            cout  lt  lt    Hello from Class B              int main         A  a1   new B      a1- gt show         Output will be   Hello from Class B    Hence with virtual function you can achieve runtime polymorphism

User · Answer

Why do we need virtual functions   Virtual functions avoid unnecessary typecasting problem  and some of us can debate that why do we need virtual functions when we can use derived class pointer to call the function specific in derived class the answer is - it nullifies the whole idea of inheritance in large system development  where having single pointer base class object is much desired   Let s compare below two simple programs to understand the importance of virtual functions   Program without virtual functions    include  lt iostream gt  using namespace std   class father       public  void get age    cout  lt  lt   Fathers age is 50 years   lt  lt  endl       class son  public father       public   void get age     cout  lt  lt   son s age is 26 years   lt  lt  endl       int main        father  p father   new father      son  p son   new son       p father- gt get age        p father   p son      p father- gt get age        p son- gt get age        return 0      OUTPUT   Fathers age is 50 years Fathers age is 50 years son s age is 26 years   Program with virtual function    include  lt iostream gt  using namespace std   class father       public          virtual void get age    cout  lt  lt   Fathers age is 50 years   lt  lt  endl       class son  public father       public   void get age     cout  lt  lt   son s age is 26 years   lt  lt  endl       int main        father  p father   new father      son  p son   new son       p father- gt get age        p father   p son      p father- gt get age        p son- gt get age        return 0      OUTPUT   Fathers age is 50 years son s age is 26 years son s age is 26 years   By closely analyzing both the outputs one can understand the importance of virtual functions

User · Answer

You need at least 1 level of inheritance and an upcast to demonstrate it  Here is a very simple  example  class Animal               public            turn the following virtual modifier on off to see what happens         virtual          std  string Says     return  quot   quot           class Dog  public Animal       public  std  string Says     return  quot Woof quot         void test         Dog  d   new Dog        Animal  a   d           refer to Dog instance with Animal pointer      std  cout  lt  lt  d- gt Says         always Woof     std  cout  lt  lt  a- gt Says         Woof or    depends on virtual

User · Answer

When you have a function in the base class  you can Redefine or Override it in the derived class    Redefining a method   A new implementation for the method of base class is given in the derived class  Does not facilitate Dynamic binding   Overriding a method  Redefining a virtual method of the base class in the derived class  Virtual method facilitates Dynamic Binding   So when you said       But earlier in the book  when learning about basic inheritance   I was   able to override base methods in derived classes without using    virtual     you were not overriding it as the method in the base class was not virtual  rather you were redefining it

User · Answer

You need virtual methods for safe downcasting  simplicity  and conciseness  That   s what virtual methods do  they downcast safely  with apparently simple and concise code  avoiding the unsafe manual casts in the more complex and verbose code that you otherwise would have   Non-virtual method  rArr  static binding                                          The following code is intentionally    incorrect     It doesn   t declare the value method as virtual  and therefore produces an unintended    wrong    result  namely 0   include  lt iostream gt  using namespace std   class Expression   public      auto value   const         - gt  double       return 0 0               This should never be invoked  really      class Number       public Expression   private      double  number        public      auto value   const         - gt  double       return number            This is OK       Number  double const number             Expression             number   number              class Sum       public Expression   private      Expression const    a       Expression const    b        public      auto value   const         - gt  double       return a - gt value     b - gt value               Uhm  bad  Very bad       Sum  Expression const  const a  Expression const  const b             Expression             a   a             b   b              auto main   - gt  int       Number const    a  3 14        Number const    b  2 72        Number const    c  1 0         Sum const       sum ab   amp a   amp b        Sum const       sum   amp sum ab   amp c             cout  lt  lt  sum value    lt  lt  endl     In the line commented as    bad    the Expression  value method is called  because the statically known type  the type known at compile time  is Expression  and the value method is not virtual   Virtual method  rArr  dynamic binding                                         Declaring value as virtual in the statically known type Expression ensures that each call will check what actual type of object this is  and call the relevant implementation of value for that dynamic type   include  lt iostream gt  using namespace std   class Expression   public      virtual     auto value   const - gt  double           0      class Number       public Expression   private      double  number        public      auto value   const - gt  double         override       return number          Number  double const number             Expression             number   number              class Sum       public Expression   private      Expression const    a       Expression const    b        public      auto value   const - gt  double         override       return a - gt value     b - gt value            Dynamic binding  OK       Sum  Expression const  const a  Expression const  const b             Expression             a   a             b   b              auto main   - gt  int       Number const    a  3 14        Number const    b  2 72        Number const    c  1 0         Sum const       sum ab   amp a   amp b        Sum const       sum   amp sum ab   amp c             cout  lt  lt  sum value    lt  lt  endl     Here the output is 6 86 as it should be since the virtual method is called virtually  This is also called dynamic binding of the calls  A little check is performed  finding the actual dynamic type of object  and the relevant method implementation for that dynamic type is called  The relevant implementation is the one in the most specific  most derived  class  Note that method implementations in derived classes here are not marked virtual  but are instead marked override  They could be marked virtual but they   re automatically virtual  The override keyword ensures that if there is not such a virtual method in some base class  then you   ll get an error  which is desirable    The ugliness of doing this without virtual methods                                                    Without virtual one would have to implement some Do It Yourself version of the dynamic binding  It   s this that generally involves unsafe manual downcasting  complexity  and verbosity  For the case of a single function  as here  it suffices to store a function pointer in the object and call via that function pointer  but even so it involves some unsafe downcasts  complexity  and verbosity  to wit   include  lt iostream gt  using namespace std   class Expression   protected      typedef auto Value func  Expression const    - gt  double       Value func  value func    public      auto value   const         - gt  double       return value func   this               Expression    value func   nullptr             Like a pure virtual      class Number       public Expression   private      double  number            static     auto specific value func  Expression const  expr           - gt  double       return static cast lt Number const  gt   expr  - gt number      public      Number  double const number             Expression             number   number         value func     amp Number  specific value func        class Sum       public Expression   private      Expression const    a       Expression const    b            static     auto specific value func  Expression const  expr           - gt  double               auto const p self    static cast lt Sum const  gt   expr            return p self- gt a - gt value     p self- gt b - gt value           public      Sum  Expression const  const a  Expression const  const b             Expression             a   a             b   b         value func     amp Sum  specific value func         auto main   - gt  int       Number const    a  3 14        Number const    b  2 72        Number const    c  1 0         Sum const       sum ab   amp a   amp b        Sum const       sum   amp sum ab   amp c             cout  lt  lt  sum value    lt  lt  endl     One positive way of looking at this is  if you encounter unsafe downcasting  complexity  and verbosity as above  then often a virtual method or methods can really help

User · Answer

OOP Answer  Subtype Polymorphism  In C    virtual methods are needed to realise polymorphism  more precisely subtyping or subtype polymorphism if you apply the definition from wikipedia   Wikipedia  Subtyping  2019-01-09  In programming language theory  subtyping  also subtype polymorphism or inclusion polymorphism  is a form of type polymorphism in which a subtype is a datatype that is related to another datatype  the supertype  by some notion of substitutability  meaning that program elements  typically subroutines or functions  written to operate on elements of the supertype can also operate on elements of the subtype   NOTE  Subtype means base class  and subtyp means inherited class   Further reading regarding Subtype Polymorphism   https   en wikipedia org wiki Subtyping https   en wikipedia org wiki Polymorphism  computer science  Subtyping   Technical Answer  Dynamic Dispatch  If you have a pointer to a base class  then the call of the method  that is declared as virtual  will be dispatched to the method of the actual class of the created object  This is how Subtype Polymorphism is realised is C     Further reading Polymorphism in C   and Dynamic Dispatch   http   www cplusplus com doc tutorial polymorphism  https   en cppreference com w cpp language virtual   Implementation Answer  Creates vtable entry  For each modifier  virtual  on methods  C   compilers usually create an entry in the vtable of the class in which the method is declared  This is how common C   compiler realise Dynamic Dispatch   Further reading vtables   https   en wikipedia org wiki Virtual method table     Example Code   include  lt iostream gt   using namespace std   class Animal   public      virtual void MakeTypicalNoise     0     no implementation needed  for abstract classes     virtual  Animal          class Cat   public Animal   public      virtual void MakeTypicalNoise                 cout  lt  lt   Meow    lt  lt  endl            class Dog   public Animal   public      virtual void MakeTypicalNoise        needs to be virtual  if subtype polymorphism is also needed for Dogs         cout  lt  lt   Woof    lt  lt  endl            class Doberman   public Dog   public      virtual void MakeTypicalNoise             cout  lt  lt   Woo  woo  woow            cout  lt  lt                   Dog  MakeTypicalNoise              int main          Animal  apObject       new Cat    new Dog    new Doberman           const   int cnAnimals   sizeof apObject  sizeof Animal        for   int i   0  i  lt  cnAnimals  i               apObject i - gt MakeTypicalNoise              for   int i   0  i  lt  cnAnimals  i               delete apObject i             return 0        Output of Example Code  Meow  Woof  Woo  woo  woow      Woof      UML class diagram of code example

User · Answer

We need virtual methods for supporting  Run time Polymorphism    When you refer to a derived class object using a pointer or a reference to the base class  you can call a virtual function for that object and execute the derived class s version of the function

User · Answer

I ve my answer in form of a conversation to be a better read     Why do we need virtual functions   Because of Polymorphism   What is Polymorphism   The fact that a base pointer can also point to derived type objects   How does this definition of Polymorphism lead into the need for virtual functions   Well  through early binding   What is early binding   Early binding compile-time binding  in C   means that a function call is fixed before the program is executed   So      So if you use a base type as the parameter of a function  the compiler will only recognize the base interface  and if you call that function with any arguments from derived classes  it gets sliced off  which is not what you want to happen   If it s not what we want to happen  why is this allowed   Because we need Polymorphism   What s the benefit of Polymorphism then   You can use a base type pointer as the parameter of a single function  and then in the run-time of your program  you can access each of the derived type interfaces e g  their member functions  without any issues  using dereferencing of that single base pointer   I still don t know what virtual functions are good for     And this was my first question   well  this is because you asked your question too soon   Why do we need virtual functions   Assume that you called a function with a base pointer  which had the address of an object from one of its derived classes  As we ve talked about it above  in the run-time  this pointer gets dereferenced  so far so good  however  we expect a method    a member function   from our derived class  to be executed  However  a same method one that has a same header  is already defined in the base class  so why should your program bother to choose the other method  In other words I mean  how can you tell this scenario off from what we used to see normally happen before   The brief answer is  a Virtual member function in base   and a little longer answer is that   at this step  if the program sees a virtual function in the base class  it knows realizes  that you re trying to use polymorphism  and so goes to derived classes using v-table  a form of late binding  to find that another method with the same header  but with -expectedly- a different implementation   Why a different implementation   You knuckle-head  Go read a good book   OK  wait wait wait  why would one bother to use base pointers  when he she could simply use derived type pointers  You be the judge  is all this headache worth it  Look at these two snippets     1   Parent  p1    amp boy  p1 - gt  task    Parent  p2    amp girl  p2 - gt  task        2   Boy  p1    amp boy  p1 - gt  task    Girl  p2    amp girl  p2 - gt  task      OK  although I think that 1 is still better than 2  you could write 1 like this either     1   Parent  p1    amp boy  p1 - gt  task    p1    amp girl  p1 - gt  task      and moreover  you should be aware that this is yet just a contrived use of all the things I ve explained to you so far  Instead of this  assume for example a situation in which you had a function in your program that used the methods from each of the derived classes respectively getMonthBenefit      double totalMonthBenefit   0      std  vector lt CentralShop  gt  mainShop      amp shop1   amp shop2   amp shop3   amp shop4   amp shop5   amp shop6   for CentralShop  x   mainShop        totalMonthBenefit    x - gt  getMonthBenefit        Now  try to re-write this  without any headaches   double totalMonthBenefit 0  Shop1  branch1    amp shop1  Shop2  branch2    amp shop2  Shop3  branch3    amp shop3  Shop4  branch4    amp shop4  Shop5  branch5    amp shop5  Shop6  branch6    amp shop6  totalMonthBenefit    branch1 - gt  getMonthBenefit    totalMonthBenefit    branch2 - gt  getMonthBenefit    totalMonthBenefit    branch3 - gt  getMonthBenefit    totalMonthBenefit    branch4 - gt  getMonthBenefit    totalMonthBenefit    branch5 - gt  getMonthBenefit    totalMonthBenefit    branch6 - gt  getMonthBenefit      And actually  this might be yet a contrived example either

User · Answer

I would like to add another use of Virtual function though it uses the same concept as above stated answers but I guess its worth mentioning   VIRTUAL DESTRUCTOR  Consider this program below  without declaring Base class destructor as virtual  memory for Cat may not be cleaned up   class Animal       public       Animal             cout  lt  lt   Deleting an Animal   lt  lt  endl           class Cat public Animal       public       Cat             cout  lt  lt   Deleting an Animal name Cat   lt  lt  endl            int main         Animal  a   new Cat        delete a      return 0      Output    Deleting an Animal    class Animal       public      virtual  Animal             cout  lt  lt   Deleting an Animal   lt  lt  endl           class Cat public Animal       public       Cat            cout  lt  lt   Deleting an Animal name Cat   lt  lt  endl            int main         Animal  a   new Cat        delete a      return 0      Output    Deleting an Animal name Cat Deleting an Animal

User · Answer

Without  virtual  you get  early binding   Which implementation of the method is used gets decided at compile time based on the type of the pointer that you call through   With  virtual  you get  late binding   Which implementation of the method is used gets decided at run time based on the type of the pointed-to object - what it was originally constructed as  This is not necessarily what you d think based on the type of the pointer that points to that object   class Base     public              void Method1        std  cout  lt  lt   Base  Method1   lt  lt  std  endl         virtual void Method2        std  cout  lt  lt   Base  Method2   lt  lt  std  endl         class Derived   public Base     public      void Method1        std  cout  lt  lt   Derived  Method1   lt  lt  std  endl         void Method2        std  cout  lt  lt   Derived  Method2   lt  lt  std  endl         Base  obj   new Derived           Note - constructed as Derived  but pointer stored as Base   obj- gt Method1          Prints  Base  Method1  obj- gt Method2          Prints  Derived  Method2    EDIT - see this question   Also - this tutorial covers early and late binding in C

User · Answer

It helps if you know the underlying mechanisms  C   formalizes some coding techniques used by C programmers   classes  replaced using  overlays  - structs with common header sections would be used to handle objects of different types but with some common data or operations  Normally the base struct of the overlay  the common part  has a pointer to a function table which points to a different set of routines for each object type  C   does the same thing but hides the mechanisms i e  the C   ptr- gt func      where func is virtual as C would be   ptr- gt func table func num   ptr       where what changes between derived classes is the func table contents   A non-virtual method ptr- func   just translates to mangled func ptr        The upshot of that is that you only need to understand the base class in order to call the methods of a derived class  i e  if a routine understands class A  you can pass it a derived class B pointer then the virtual methods called will be those of B rather than A since you go through the function table B points at

User · Answer

Are you familiar with function pointers  Virtual functions are a similar idea  except you can easily bind data to virtual functions  as class members   It is not as easy to bind data to function pointers  To me  this is the main conceptual distinction  A lot of other answers here are just saying  because    polymorphism

User · Answer

i think you are referring to the fact once a method is declared virtual you don t need to use the  virtual  keyword in overrides   class Base   virtual void foo        class Derived   Base       void foo       this is overriding Base  foo      If you don t use  virtual  in Base s foo declaration then Derived s foo would just be shadowing it

User · Answer

About efficiency  the virtual functions are slightly less efficient as the early-binding functions     This virtual call mechanism can be made almost as efficient as the  normal function call  mechanism  within 25    Its space overhead is one pointer in each object of a class with virtual functions plus one vtbl for each such class   A tour of C   by Bjarne Stroustrup

[c++] Why do we need virtual functions in C++?

Examples related to c++

Examples related to virtual-functions