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
This is well-defined behavior. If a were a B* this wouldn’t compile. The reason is that member access is resolved statically by the compiler, not dynamically at run-time. Many C++ books suggest that you avoid coding like this because it confuses less experienced coders.
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
Is there something wrong with this approach? Answer from Bjarne Stroustrup: Can I call a virtual function from a constructor? Yes, but be careful. It may not do what you expect. In a constructor, the virtual call mechanism is disabled because overriding from derived classes hasn’t yet happened. Objects are constructed from the base up, … Read more
AMD processor in the early-gigahertz era had a 40 cycle penalty every time you called a function Huh.. so large.. There is an “Indirect branch prediction” method, which helps to predict virtual function jump, IF there was the same indirect jump some time ago. There is still a penalty for first and mispredicted virt. function … 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
Overriding essentially means that either the Base class method or the Derived class method will be called at run-time depending on the actual object pointed by the pointer. It implies that: i.e: Every place where the Base class method can be called can be replaced by call to Derived class method without any change to … 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
What is function hiding? … is a form of name hiding. A simple example: void foo(int); namespace X { void foo(); void bar() { foo(42); // will not find `::foo` // because `X::foo` hides it } } This also applies to the name lookup in a base class: class Base { public: void foo(int); }; … Read more