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
This answer is no longer correct as of C++20. No. From [dcl.constexpr]/3 (7.1.5, “The constexpr specifier”): The definition of a constexpr function shall satisfy the following requirements: — it shall not be virtual
There are two costs to a virtual function call: The vtable lookup and the function call. The vtable lookup is already taken care of by the hardware. Modern CPUs (assuming you’re not working on a very simple embedded CPU) will predict the address of the virtual function in their branch predictor and speculatively execute it … Read more
This depends on your goals. You can use version 1 if you Intend to replace brakes of a car (at runtime) Intend to pass Car around to non-template functions I would generally prefer version 1 using the runtime polymorphism, because it is still flexible and allows you to have the Car still have the same … Read more
This is a pure virtual function. This means, that subclasses have to implement this function, otherwise they are abstract, meaning you cannot create objects of that class. class ISomeInterface { public: virtual std::string ToString( ) = 0; } class SomeInterfaceImpl : public ISomeInterface { public: virtual std::string ToString( ) { return “SomeInterfaceImpl”; } } The … Read more
There is no need to use a virtual destructor when any of the below is true: No intention to derive classes from it No instantiation on the heap No intention to store with access via a pointer to a superclass No specific reason to avoid it unless you are really so pressed for memory.
You can’t check for override of virtual function portably. You need to bring the knowledge to the Solver, preferably via type as opposed to run-time flag. One (type-based) way is to check for presence or absence of a interface, via dynamic_cast. A probably better way is to provide overloads of solve function, in your case … Read more
It will not do anything but the method you have there F() is also not polymorphic. It becomes very easy to make mistake in code if you started to use base class reference hence you are warned. Of course it can be what you want, hence the new keyword just make it more explicit E.g. … Read more
You use virtual functions when you want to override a certain behavior (read method) for your derived class rather than the one implemented for the base class and you want to do so at run-time through a pointer to the base class. The classic example is when you have a base class called Shape and … Read more
You can cause the JIT to devirtualize your interface calls by using a struct with a constrained generic. public SomeObject<TMathFunction> where TMathFunction: struct, IMathFunction { private readonly TMathFunction mathFunction_; public double SomeWork(double input, double step) { var f = mathFunction_.Calculate(input); var dv = mathFunction_.Derivate(input); return f – (dv * step); } } // … var … Read more