Dyamic vs Static Polymorphism in C++ : which is preferable?
c++, optimization, polymorphism, static-polymorphism
Solution
A switch is nothing more than a sequence of jumps that -after optimized- becomes a jump to an address looked-up by a table. Exactly like a virtual function call is.
If you have to jump depending on a type, you must first select the type. If the selection cannot be done at compile time (essentially because it depends on the input) you must always perform two operation: select & jump. The syntactic tool you use to select doesn't change the performance, since optimize the same.
In fact you are reinventing the v-table.
Problem
I understand that dynamic/static polymorphism depends on the application design and requirements. However, is it advisable to ALWAYS choose static polymorphism over dynamic if possible? In particular, I can see the following 2 design choice in my application, both of which seem to be advised against: Implement Static polymorphism using CRTP: No vtable lookup overhead while still providing an interface in form of template base class. But, uses a Lot of switch and static_cast to access the correct class/method, which is hazardous Dynamic Polymorphism: Implement interfaces (pure virtual classes), associating lookup cost for even trivial functions like accessors/mutators My application is very time critical, so am in favor of static polymorphism. But need to know if using too many static_cast is an indication of poor design, and how to avoid that without incurring latency. EDIT: Thanks for the insight. Taking a specific case, which of these is a better approach? ``` class IMessage_Type_1 { virtual long getQuantity() =0; ... } class Message_Type_1_Impl: public IMessage_Type_1 { long getQuantity() { return _qty;} ... } ``` OR ``` template <class T> class TMessage_Type_1 { long getQuantity() { return static_cast<T*>(this)->getQuantity(); } ... } class Message_Type_1_Impl: public TMessage_Type_1<Message_Type_1_Impl> { long getQuantity() { return _qty; } ... } ``` Note that there are several mutators/accessors in each class, and I do need to specify an interface in my application. In static polymorphism, I switch just once - to get the message type. However, in dynamic polymorphism, I am using virtual functions for EACH method call. Doesnt that make it a case to use static poly? I believe static_cast in CRTP is quite safe and no performance penalty (compile time bound) ?