Optimizing out virtual function calls at compile-time
Will the compiler even attempt to do it? Here's the example I'm working with...
Code:
//MY_HEADER_H
class Base{
public:
virtual void method1() = 0;
virtual void method2() = 0;
//...
};
class Derived1 : public Base{
public:
virtual void method1();
virtual void method2();
private:
RandomData m_foo;
};
class Derived2 : public Base{
public:
virtual void method1();
virtual void method2();
private:
OtherRandomData m_foo;
};
//MY_MAIN_CPP
#include "MyHeader.h"
int main(void){
Base* foo = new Derived1; //perhaps switch to Derived2
foo->method1();
foo->method2();
delete foo;
return 0;
}
As you can see here, I'm basically defining a common interface for easy testing. I'd like to be able to switch out between one implementation and another to test changes in performance. Other than that, the "virtual-ness" is not used; function calls can be determined at compile-time by visual inspection. I was wondering if the majority of compilers, or more specifically VS2010, would be intelligent to pick up on this and inline the proper calls or am I going to suffer the performance hit from this. Since this code needs to run quite fast, I'd like to avoid this but would also like to avoid the CRT pattern for reasons of readability (personal preference) and reworking of code.
Thoughts?
