virtual vs. function pointer

[JonLT]

Hi

I was just wandering what the difference between a overloaded virtual function and a function pointer member variable is?
Im looking for the best execution time.
Heres an example:

class someClass : public someOtherClass
{
public:
  virtual void f(); // this function is overloading f() in someOtherClass
}
 

class isThisBetter
{
public:
  fPtr f;
}
 

A pointer is assigned to f at some point after creation.

[weaknessforcats]

class isThisBetter
{
public:
fPtr f;
}

Actually, this is worse because you have a public data member accessible (and changeable) by any function in the program. When this gets screwed up, you will have a whole lotta suspects.

There is no similarity between a function pointer and a virtual function.

A function pointer is a pointer to a function of the kind used to define the function pointer. That means the f public data member in your example won't compile because the compiler does not know what sorts of arguments and return type (if any) are required. You need to tell the compiler what to do. Below is your f defined as a pointer to a function that takes two int arguments and returns an int:

class isThisBetter
{
public:
    int (*f)(int,int);
  };
 

This means f can contain the address of any function so long as it has two int arguments and returns an int.


The virtual keyword on a member function tells the compiler that if you use a pointer or reference to a base class object and there is a choice between calling the base class function or the derived class member function, the derived member function is to be called.

Remove the virtual keyword and the compiler is told that if there is a choice between the base class function and the derived function, use the base function.

Therefore, the virtual keyword allows derived class function to be called using a base class object pointer or reference. And this is how you do object-oriented coding in C++.

While it is true the addresses of these member functions are used in the class virtual function table, the table does not contain function pointers as defined in C++.

You use a function pointer when you and not your object needs to make a run-time decision as to what function to call.

[TamusJRoyce]

From what I've learned dealing with COM and DirectX, using virtual methods does take a hit on both performance and overhead vs. using a classic C style callback function (function pointer). This is due to the vthunk table having to be referenced for each access to the virtual function you are overloading.

But unless you are doing 1000 loops on a time critical pixel-to-screen operation, performance probably won't be hit almost at all using a virtual function vs. a C style callback. Heck. DirectX and COM are based on virtual functions (look up how to do iunkown interface if you're curious).

But using virtual inefficiently is kind of why Java runs a lot slower (compiled natively) than C/C++ (but it helps incredibly with garbage collection), so don't go wild over using it if you are concerned about efficiency (which means you're a good programmer : ).

Note: Personally, I would declare an inline method (inline defaultly if body of function is left within the class) and then call that method inside the virtual method. Then avoid using the virtual function unless at all nessesary (i.e. when you have to call it directly from a base class).
The inline will allow the compiler to determine whether or not to inline it based on the size of the function body and the optimization parameters you send it. Then test the various optimizations and record the running time & size of the executable, choosing how much performance vs. size (both in memory and on disk) you need.

Feel free for anyone to comment on me here. I don't always compose my ideas correctly, nor am I right that much either :-b...

[JonLT]

Thank you very much. I am actually in the process of making a raytracer, and i'd like it to have a reasonable frame rate, so every little improvement is welcome, and from what you are saying it sounds like i need to avoid virtual function calls in the main loop.

The reason i was using them in the first place, was to be able to do intersection tests with different objects by calling an intersectionTest() function on some baseObject class. But i guess i'll just scrap the different objects and only use triangles.
Or perhaps a function pointer in the baseObject... some thing like this:

class baseObject
{
public:
   float intersectionTest(Ray r)
   {
      iTest(r);
   }
protected:
   fPtr iTest;
};
 

[TamusJRoyce]

I'm glad I could help.

Yeah. For ray-tracing and just using the function as a wrapper as it look like you are doing, I would try to call it inline without a pointer, if I could.

And using the keyword register for small parameters would be of utmost importance (placed appropriately, since using them everywhere can slow down your program), too.

It's against the rules of the forum to post links to outside the forum, but pm me directly if you have any interesting tutorials and such about ray-tracing and you have some time (it kinda parallels 3D engines which I'm slowly learning the math on)

[romanize]

Thank you very much. I am actually in the process of making a raytracer, and i'd like it to have a reasonable frame rate, so every little improvement is welcome, and from what you are saying it sounds like i need to avoid virtual function calls in the main loop.

The reason i was using them in the first place, was to be able to do intersection tests with different objects by calling an intersectionTest() function on some baseObject class. But i guess i'll just scrap the different objects and only use triangles.
Or perhaps a function pointer in the baseObject... some thing like this:

class baseObject
{
public:
   float intersectionTest(Ray r)
   {
      iTest(r);
   }
protected:
   fPtr iTest;
};
 

just a - possibly obvious - note:
"float intersectionTest(const Ray& r)" may perform better.

[romanize]

...
And using the keyword register for small parameters would be of utmost importance (placed appropriately, since using them everywhere can slow down your program), too.
...

Similarly, be aware of the many optimizations the hardware takes care of. If you have, say, 10 different objects to intersect with, the referenced locations may end up very close to the processor after several calls, such that there is no - or little - memory overhead.

As for the keyword register, I'd trust the compiler to do the job.

Correct, if I'm wrong, please.

The best thing I to do some benchmarks, I guess.