It’s sometimes easier to understand with an example: class PureVirtual { public: virtual void methodA() = 0; virtual void methodB() = 0; }; class Base : public PureVirtual { public: virtual void methodA(); void methodC(); private: int x; }; class Derived : public Base { public: virtual void methodB(); private: int y; }; So, given … Read more
Typically final will not be used on the base class’ definition of a virtual function. final will be used by a derived class that overrides the function in order to prevent further derived types from further overriding the function. Since the overriding function must be virtual normally it would mean that anyone could override that … Read more
The answer is in the C# specification section 7.3 and section 7.5.5.1 I broke down the steps used for choosing the method to invoke. First, the set of all accessible members named N (N=Foo) declared in T (T=class D) and the base types of T (class C) is constructed. Declarations that include an override modifier … Read more
So basically if in your ancestor class you want a certain behaviour for a method. If your descendent uses the same method but has a different implementation you can override it, If it has a virtual keyword. using System; class TestClass { public class Dimensions { public const double pi = Math.PI; protected double x, … Read more
You do get the surprising result that if you have a child, you can’t call foo, but you can cast it to a base and then call foo. child *c = new child(); c->foo; // compile error (can’t access private member) static_cast<base *>(c)->foo(); // this is fine, but still calls the implementation in child I … Read more
For the interface, the addition of the abstract, or even the public keywords would be redundant, so you omit them: interface MyInterface { void Method(); } In the CIL, the method is marked virtual and abstract. (Note that Java allows interface members to be declared public abstract). For the implementing class, there are some options: … 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.
I ran some timings on a 3ghz in-order PowerPC processor. On that architecture, a virtual function call costs 7 nanoseconds longer than a direct (non-virtual) function call. So, not really worth worrying about the cost unless the function is something like a trivial Get()/Set() accessor, in which anything other than inline is kind of wasteful. … Read more
You can’t do it directly, but there are a couple of ways to simulate it, with the help of the Non-Virtual Interface idiom. Use covariance on raw pointers, and then wrap them struct Base { private: virtual Base* doClone() const { … } public: shared_ptr<Base> Clone() const { return shared_ptr<Base>(doClone()); } virtual ~Base(){} }; struct … Read more
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