What is the difference between an abstract method and a virtual method? In which cases is it recommended to use abstract or virtual methods? Which one is the best approach?

What is the difference between an abstract method and a virtual method?

I&#39;m learning C++ and I&#39;m just getting into virtual functions.

From what I&#39;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&#39;t find a straightforward answer online.



Why do we need virtual functions in C++?

I&#39;m getting a warning from ReSharper about a call to a virtual member from my objects constructor. 

Why would this be something not to do?

Virtual member call in a constructor

Say I have classes `Foo` and `Bar` set up like this:

    class Foo
    {
    public:
        int x;
        
        virtual void printStuff()
        {
            std::cout &lt;&lt; x &lt;&lt; std::endl;
        }
    };

    class Bar : public Foo
    {
    public:
        int y;

        void printStuff()
        {
            // I would like to call Foo.printStuff() here...
            std::cout &lt;&lt; y &lt;&lt; std::endl;
        }
    };

As annotated in the code, I&#39;d like to be able to call the base class&#39;s function that I&#39;m overriding. In Java there&#39;s the `super.funcname()` syntax. Is this possible in C++?

Can I call a base class&#39;s virtual function if I&#39;m overriding it?

I have heard that C++ class member function templates can&#39;t be virtual.  Is this true? 

If they can be virtual, what is an example of a scenario in which one would use such a function?

Can a class member function template be virtual?

Why does C++ not have a virtual constructor?

Why do we not have a virtual constructor in C++?

Suppose I have two C++ classes:

    class A
    {
    public:
      A() { fn(); }

      virtual void fn() { _n = 1; }
      int getn() { return _n; }

    protected:
      int _n;
    };

    class B : public A
    {
    public:
      B() : A() {}

      virtual void fn() { _n = 2; }
    };


If I write the following code:


    int main()
    {
      B b;
      int n = b.getn();
    }

One might expect that `n` is set to 2.

It turns out that `n` is set to 1. Why?


Calling virtual functions inside constructors

As far as I understand, the introduction of `override` keyword in C++11 is nothing more than  a check to make sure that the function being implemented is the `override`ing of a `virtual` function in the base class.

Is that it?

Is the &#39;override&#39; keyword just a check for a overridden virtual method?

With the struct definition given below...

    struct A {
        virtual void hello() = 0;
    };

Approach #1:

    struct B : public A {
        virtual void hello() { ... }
    };

Approach #2:

    struct B : public A {
        void hello() { ... }
    };

Is there any difference between these two ways to override the hello function?

C++ &quot;virtual&quot; keyword for functions in derived classes. Is it necessary?

Here is some code from [MSDN][1]:

    // compile with: /target:library 
    public class D
    {
        public virtual void DoWork(int i)
        {
            // Original implementation.
        }
    }
    
    public abstract class E : D
    {
        public abstract override void DoWork(int i);
    }
    
    public class F : E
    {
        public override void DoWork(int i)
        {
            // New implementation.
        }
    }

  [1]: http://msdn.microsoft.com/en-us/library/ms173150.aspx

Can anyone explain the above code with respect to the differences between abstract and virtual methods?

Difference between virtual and abstract methods

I got this question when I received a code review comment saying virtual functions need not be inline. 

I thought inline virtual functions could come in handy in scenarios where functions are called on objects directly. But the counter-argument came to my mind is -- why would one want to define virtual and then use objects to call methods?

Is it best not to use inline virtual functions, since they&#39;re almost never expanded anyway?

Code snippet I used for analysis:


    class Temp
    {
    public:
    
    	virtual ~Temp()
    	{
    	}
    	virtual void myVirtualFunction() const
    	{
    		cout&lt;&lt;&quot;Temp::myVirtualFunction&quot;&lt;&lt;endl;
    	}
    
    };
    
    class TempDerived : public Temp
    {
    public:
    	
    	void myVirtualFunction() const
    	{
    		cout&lt;&lt;&quot;TempDerived::myVirtualFunction&quot;&lt;&lt;endl;
    	}
    
    };
    
    int main(void) 
    {
    	TempDerived aDerivedObj;
    	//Compiler thinks it&#39;s safe to expand the virtual functions
    	aDerivedObj.myVirtualFunction();
    
    	//type of object Temp points to is always known;
        //does compiler still expand virtual functions?
    	//I doubt compiler would be this much intelligent!
    	Temp* pTemp = &amp;aDerivedObj;
    	pTemp-&gt;myVirtualFunction();
    
    	return 0;
    }



Are inline virtual functions really a non-sense?

Is it possible to write *virtual* methods in Java, as one would do in C++?

Or, is there a proper Java approach which you can implement that produces similar behavior? Could I please have some examples?


Can you write virtual functions / methods in Java?

In my class design, I use abstract classes and virtual functions extensively. I had a  feeling that virtual functions affects the performance. Is this true? But I think this performance difference is not noticeable and looks like I am doing premature optimization. Right?

Virtual functions and performance - C++

We all know what virtual functions are in C++, but how are they implemented at a deep level?

Can the vtable be modified or even directly accessed at runtime?

Does the vtable exist for all classes, or only those that have at least one virtual function? 

Do abstract classes simply have a NULL for the function pointer of at least one entry?

Does having a single virtual function slow down the whole class? Or only the call to the function that is virtual?  And does the speed get affected if the virtual function is actually overwritten or not, or does this have no effect so long as it is virtual.



How are virtual functions and vtable implemented?

Having at least one virtual method in a C++ class (or any of its parent classes) means that the class will have a virtual table, and every instance will have a virtual pointer.

So the memory cost is quite clear.  The most important is the memory cost on the instances (especially if the instances are small, for example if they are just meant to contain an integer: in this case having a virtual pointer in every instance might double the size of the instances.  As for the memory space used up by the virtual tables, I guess it is usually negligible compared to the space used up by the actual method code.

This brings me to my question: is there a measurable performance cost (i.e. speed impact) for making a method virtual?  There will be a lookup in the virtual table at runtime, upon every method call, so if there are very frequent calls to this method, and if this method is very short, then there might be a measurable performance hit?  I guess it depends on the platform, but has anyone run some benchmarks?

The reason I am asking is that I came across a bug that happened to be due to a programmer forgetting to define a method virtual.  This is not the first time I see this kind of mistake.  And I thought: why do we *add* the virtual keyword when needed instead of *removing* the virtual keyword when we are absolutely sure that it is *not* needed?  If the performance cost is low, I think I will simply recommend the following in my team: simply make *every* method virtual by default, including the destructor, in every class, and only remove it when you need to.  Does that sound crazy to you?

What is the performance cost of having a virtual method in a C++ class?

I sometimes notice programs that crash on my computer with the error: &quot;pure virtual function call&quot;.

How do these programs even compile when an object cannot be created of an abstract class?

Where do &quot;pure virtual function call&quot; crashes come from?

C# methods in interfaces are declared without using the `virtual` keyword, and overridden in the derived class without using the `override` keyword.

Is there a reason for this?  I assume that it is just a language convenience, and obviously the CLR knows how to handle this under the covers (methods are not virtual by default), but are there other technical reasons?

Here is the IL that a derived class generates:

    class Example : IDisposable {
        public void Dispose() { }
    }

    .method public hidebysig newslot virtual final 
            instance void  Dispose() cil managed
    {
      // Code size       2 (0x2)
      .maxstack  8
      IL_0000:  nop
      IL_0001:  ret
    } // end of method Example::Dispose

Notice that the method is declared `virtual` `final` in the IL. 

Why are C# interface methods not declared abstract or virtual?

Unlike Java, why does C# treat methods as non-virtual functions by default?  Is it more likely to be a performance issue rather than other possible outcomes?

I am reminded of reading a paragraph from Anders Hejlsberg about several advantages the existing architecture is bringing out. But, what about side effects? Is it really a good trade-off to have non-virtual methods by default?

Why C# implements methods as non-virtual by default?

Is there ever a good reason to *not* declare a virtual destructor for a class?  When should you specifically avoid writing one?

When should you not use virtual destructors?

I have a base class with a virtual function and I want to override that function in a derived class. Is there some way to make the compiler check if the function I declared in the derived class actually overrides a function in the base class? I would like to add some macro or something that ensures that I didn&#39;t accidentally declare a new function, instead of overriding the old one.

Take this example:

    class parent {
    public:
      virtual void handle_event(int something) const {
        // boring default code
      }
    };

    class child : public parent {
    public:
      virtual void handle_event(int something) {
        // new exciting code
      }
    };

    int main() {
      parent *p = new child();
      p-&gt;handle_event(1);
    }

Here `parent::handle_event()` is called instead of `child::handle_event()`, because the child&#39;s method misses the `const` declaration and therefore declares a new method. This could also be a typo in the function name or some minor difference in the parameters types. It can also easily happen if the interface of the base class changes and somewhere some derived class wasn&#39;t updated to reflect the change.

Is there some way to avoid this problem, can I somehow tell the compiler or some other tool to check this for me? Any helpful compiler flags (preferably for g++)? How do you avoid these problems?


Safely override C++ virtual functions

I know virtual methods from PHP or Java.

How can they be implemented in Python?

Or have I to define an empty method in an abstract class and override it?

How to implement virtual methods in Python?

Is it possible for an inherited class to implement a virtual function with a different return type (not using a template as return)?



C++ virtual function return type

Assignment Operator in C++ can be made virtual. Why is it required? Can we make other operators virtual too?

virtual assignment operator C++

In Java you can mark method as final to make it *impossible* to override.

In C# you have to mark method as virtual to make it *possible* to override.

Does it mean that in C# you should mark all methods virtual (except a few ones that you don&#39;t want to be overridden), since most likely you don&#39;t know in what way your class can be inherited?

Should I mark all methods virtual?

&gt; **Possible Duplicate:**  
&gt; [C++ static virtual members?](https://stackoverflow.com/questions/1820477/c-static-virtual-members)  

&lt;!-- End of automatically inserted text --&gt;

Can we have a static virtual functions? If not, then WHY?

    class X
    {
    public:
           virtual static void fun(){} // Why we cant have static virtual function in C++?
    };

Can we have a static virtual functions? If not, then WHY?

As I understand it, the `override` keyword states that a given declaration implements a base `virtual` method, and the compilation should fail if there is no matching base method found.

My understanding of the `final` keyword is that it tells the compiler that no class shall override this `virtual` function.

So is `override final` redundant? [It seems to compile fine][1]. What information does `override final` convey that `final` does not? What is the use case for such a combination?


  [1]: http://ideone.com/9V7zNx

Does final imply override?

I have an abstract class that is declared as follow:

    class my_type {
    public:
    	virtual ~my_type() = default;
    	virtual void do_something() = 0;
    };

Is it considered good practice to declare the destructor like this, with the `default` keyword? Is there a better way?

Also, is `= 0` a modern (C++11) way of specifying no default implementation, or there is a better way?

Should I default virtual destructors?

[Wikipedia](http://en.wikipedia.org/wiki/C%2B%2B11#Explicit_overrides_and_final) has the following example on the C++11 final modifier:

    struct Base2 {
        virtual void f() final;
    };
     
    struct Derived2 : Base2 {
        void f(); // ill-formed because the virtual function Base2::f has been marked final
    };

I don&#39;t understand the point of introducing a virtual function and immediately marking it as final. Is this simply a bad example, or is there more to it?

What&#39;s the point of a final virtual function?

What &#39;s the practical usage of virtual functions in c#?

Practical usage of virtual functions in c#

Is there is any reason to make the permissions on an overridden C++ virtual function different from the base class?  Is there any danger in doing so?

For example:

    class base {
        public:
            virtual int foo(double) = 0;
    }

    class child : public base {
        private:
            virtual int foo(double);
    }
 
The [C++ faq](https://isocpp.org/wiki/faq/proper-inheritance#hiding-inherited-public) says that it is a bad idea, but doesn&#39;t say why.

I have seen this idiom in some code and I believe that the author was attempting to make the class final, based on an assumption that it is not possible to override a private member function.  However, [This article](http://www.gotw.ca/publications/mill18.htm) shows an example of overriding private functions.  Of course [another part of the C++ faq](http://www.parashift.com/c++-faq-lite/strange-inheritance.html#faq-23.4) recommends against doing so.

My concrete questions:

 1. Is there any technical problem with using a different permission for virtual methods in derived classes vs base class?

 2. Is there any legitimate reason to do so?



Overriding public virtual functions with private functions in C++

I know that virtual functions have an overhead of dereferencing to call a method. But I guess with modern architectural speed it is almost negligible. 

1. Is there any particular reason why all functions in C++ are not virtual as in Java?
2. From my knowledge, defining a function virtual in a base class is sufficient/necessary. Now when I write a parent class, I might not know which methods would get over-ridden. So does that mean that while writing a child class someone would have to edit the parent class. This sounds like inconvenient and sometimes not possible?

**Update:**  
Summarizing from Jon Skeet&#39;s answer below:  

It&#39;s a trade-off between explicitly making someone realize that they are inheriting functionality [which has potential risks in themselves [(check Jon&#39;s response)] [and potential small performance gains] **with a trade-off** for less flexibility, more code changes, and a steeper learning curve.

**Other reasons from different answers:**  

Virtual functions cannot be in-lined because inlining have to happen at runtime. This have performance impacts when you expect you functions benefits from inlining.

There might be potentially other reasons, and I would love to know and summarize them.


Why not have all the functions as virtual in C++?

I have the following code inside the .h file and I&#39;m not sure what does the assignment statement do and how is it called properly?

    virtual void yield() = 0;

I thought that the function returns a value of 0 by default but since this function returns void I am a little bit confused. Can anyone comment on this and maybe say how can I refer to this assignment, I mean how is it called in C++ jargon?

Thanks.

C++ header file and function declaration ending in &quot;= 0&quot;

I recently came to know that in C++ pure virtual functions can optionally have a body. 

What are the real-world use cases for such functions?

Use-cases of pure virtual functions with body?

For this code:

    class B1{
    public:  
      virtual void f1() {}  
    };
     
    class D : public B1 {
    public:
      void f1() {}
    };
    
    int main () {
    	B1 *b1 = new B1();
    	D  *d  = new D();
    	
    	return 0;
    }

After compilation, the vtable I get with `g++ -fdump-class-hierarchy` is:

    Vtable for B1
    B1::_ZTV2B1: 3u entries
    0     (int (*)(...))0
    8     (int (*)(...))(&amp; _ZTI2B1)
    16    B1::f1
    
   
    Vtable for D
    D::_ZTV1D: 3u entries
    0     (int (*)(...))0
    8     (int (*)(...))(&amp; _ZTI1D)
    16    D::f1
   
I failed to understand what do the entries like *(int (*)(...))0* correspond to. Of course it means something like, it is a function which returns an int and takes unlimited number of arguments, I don&#39;t understand anything further.
To which function does this function pointer correspond to? and how do you know that? Mine is a 64 bit machine.

The second function pointer has an address associated at end?? To whom does that correspond to?

*EDIT*

The compiler, I use is g++:

    g++ -v
    Using built-in specs.
    Target: x86_64-suse-linux
    Configured with: ../configure --prefix=/usr --infodir=/usr/share/info --mandir=/usr/share/man --libdir=/usr/lib64 --libexecdir=/usr/lib64 --enable-languages=c,c++,objc,fortran,obj-c++,java,ada --enable-checking=release --with-gxx-include-dir=/usr/include/c++/4.4 --enable-ssp --disable-libssp --with-bugurl=http://bugs.opensuse.org/ --with-pkgversion=&#39;SUSE Linux&#39; --disable-libgcj --disable-libmudflap --with-slibdir=/lib64 --with-system-zlib --enable-__cxa_atexit --enable-libstdcxx-allocator=new --disable-libstdcxx-pch --enable-version-specific-runtime-libs --program-suffix=-4.4 --enable-linux-futex --without-system-libunwind --with-arch-32=i586 --with-tune=generic --build=x86_64-suse-linux
    Thread model: posix
    *gcc version 4.4.1 [gcc-4_4-branch revision 150839] (SUSE Linux)*



All Virtual Functions Solutions on Gang of Coders

Total of 34 Virtual Functions Solutions