They can result if you try to make a virtual function call from a constructor or destructor. Since you can’t make a virtual function call from a constructor or destructor (the derived class object hasn’t been constructed or has already been destroyed), it calls the base class version, which in the case of a pure … Read more
How are virtual functions implemented at a deep level? From “Virtual Functions in C++”: Whenever a program has a virtual function declared, a v – table is constructed for the class. The v-table consists of addresses to the virtual functions for classes that contain one or more virtual functions. The object of the class containing … Read more
Your question made me curious, so I went ahead and ran some timings on the 3GHz in-order PowerPC CPU we work with. The test I ran was to make a simple 4d vector class with get/set functions class TestVec { float x,y,z,w; public: float GetX() { return x; } float SetX(float to) { return x=to; … Read more
Virtual functions can be inlined sometimes. An excerpt from the excellent C++ faq: “The only time an inline virtual call can be inlined is when the compiler knows the “exact class” of the object which is the target of the virtual function call. This can happen only when the compiler has an actual object rather … Read more
From wikipedia In Java, all non-static methods are by default “virtual functions.” Only methods marked with the keyword final, which cannot be overridden, along with private methods, which are not inherited, are non-virtual.
Virtual methods have an implementation and provide the derived classes with the option of overriding it. Abstract methods do not provide an implementation and force the derived classes to override the method. So, abstract methods have no actual code in them, and (non-abstract) subclasses HAVE TO override the method. Virtual methods can have code, which … Read more
That’s indeed the idea. The point is that you are explicit about what you mean, so that an otherwise silent error can be diagnosed: struct Base { virtual int foo() const; }; struct Derived : Base { virtual int foo() // whoops! { // … } }; The above code compiles, but is not what … Read more
They are exactly the same. There is no difference between them other than that the first approach requires more typing and is potentially clearer.
Calling virtual functions from a constructor or destructor is dangerous and should be avoided whenever possible. All C++ implementations should call the version of the function defined at the level of the hierarchy in the current constructor and no further. The C++ FAQ Lite covers this in section 23.7 in pretty good detail. I suggest … Read more
Hear it from the horse’s mouth. 🙂 From Bjarne Stroustrup’s C++ Style and Technique FAQ Why don’t we have virtual constructors? A virtual call is a mechanism to get work done given partial information. In particular, “virtual” allows us to call a function knowing only any interfaces and not the exact type of the object. … Read more