Static functions vs virtual functions in terms of speed - c++

Question

I have some trouble. While planning my program, I consider 2 versions:
Use static methods in classes with additional parameter (pointer to copy of a class).
Use virtual methods (vtable)
What is faster? Why?
Edit: I need to make next algorithm: array should be storing pointers to method of different classes (they meet diff. game objects), for example, method Draw().
The main task is storing and calling methods of different classes.

Answer 1

At this point, you probably shouldn't be thinking about micro-optimisations at all - focus on choosing efficient algorithms, and making your code clear and correct; then identify any bottlenecks that prevent it from performing as required. Having said that, here are some thoughts in the unlikely event that you do find that virtual dispatch becomes an issue.
The two are not equivalent - the first (if I understand what you're saying) is trying to emulate a non-virtual function by explicitly passing a this-like pointer to a static function, and is likely to be exactly as fast as the non-static equivalent. It will behave differently to a virtual function, and so can't be used if you need virtual dispatch.
A non-virtual function will (almost certainly) be a bit faster than a virtual function - it's more likely to be inlined, and if not inlined it can be called directly rather than looked up at runtime. Therefore, only declare functions virtual when you need virtual dispatch.
In extreme circumstances, you might be able to save a level of indirection over virtual functions, by storing function pointers in the object rather than using the compiler-generated virtual dispatch. You should only do this as a last resort, if you find that virtual dispatch is a serious bottle-neck, and you can't sensibly redesign your algorithm to avoid it.

Answer 2

First, virtual functions and what you are proposing have different
semantics. If you need different behavior because you have different
types of objects, then it's highly unlikely that you can do better than
the compilers implementation of virtual functions. If you don't need
it, then just don't declare the function virtual.
And don't worry about the performance issue until you know it is one.
If, after getting the code to work, you do find performance issues due
to virtual function calls (usually because the compiler can't inline the
function, so you loose all of the optimizations which would follow
inlining), you can, punctually, avoid the virtual function cost if you
design the class correctly. Supposing the function in question is
f():
class Base
{
virtual void doF() = 0;
public:
void f() { doF(); }
};
class Derived : public Base
{
virtual void doF() { f(); }
public:
void f() { /* ... */ }
};
If you do this, and you have, for example, a tight loop where you're
constantly calling f() on the same object, you can do something like:
void
tightLoop( Base& object )
{
Derived& o = dynamic_cast<Derived&>( object );
for ( /* ... */ ) {
o.f();
}
}
If you do this, of course, tightLoop can only be called with an object
which is actually Derived.