Function pointers vs if statements - speed.

>> So, with this in mind, is using function pointers extensively actually beneficial vs using if statements?
Um, it really depends on what you are trying to do. In C++ it is preferable to use functors rather than function pointers.
http://www.newty.de/fpt/functor.html#chapter4

#include <iostream>
 
struct functor
{
	void operator()() const
	{
		std::cout << "hello world" << std::endl;
	}
};
 
template <typename funcT>
void foo(funcT const & func)
{
	func();
}
 
int main()
{
	foo(functor());
}

Select allOpen in new window

Hm, I haven't heard of functors before... Why does it depend on what I'm trying to do?

One thing I don't understand is why you need your performence based on using function pointers / if statements? Honestly sure one may be slower then the other, but it is really not that significant versus changing the programs logic to be optimal

>> What I mean is, there is no right or wrong answer to your question
Or, to put it another way, if you need to use function pointers then use them and if you don't need to use them then don't. Use the right tool for the right job. I wouldn't use a chain saw to cut my hair just because it is quicker :)

Thanks. :)

Rishadan: The reason I ask is because this will be called hundreds of times per second, so clearly if there is a better way, I'll take it. :)

Hmm. Why are you calling this hundreds of times per second. Maybe you could improve on your logic such that you don't have to call it 100 times per second.

well to be honest 100 times per second, is slow is computer terms

Or rather 100 times per second is not many at all...

Sorry, that should have been hundreds of thousands - probably going into the double digit millions.

>>Maybe you could improve on your logic such that you don't have to call it 100 times per second.
No, unfortunately not.

>>well to be honest 100 times per second, is slow is computer terms
Agreed. :)

evilrix's answer is excellent of course, and is the one to go with. But I just wanted to clarify the wiki quote (in case it needs clarification). If the function call will be done in an inner loop (ie. will be executed a lot of times), then it's likely to be faster to make use of if statements for choosing which function to call. If the function call is not done regularly, then the application design or code clarity or ... might push you towards using function pointers.

But I'd hold on to the "premature optimization is the root of all evil" quote ;)

I wouldn't do either. I'd use polymorphism.

>>I wouldn't do either. I'd use polymorphism.
How exactly do you mean?

Thanks,
Uni

Btw, I don't mean how do you use polymorphism, but how would it help in this type of case?

>> but how would it help in this type of case?
Rather than using function pointer I'd use polymorphic functors.

#include <iostream>
 
struct functor_base
{
	virtual void operator()() const = 0;
};
 
struct functor1 : functor_base
{
	virtual void operator()() const
	{
		std::cout << "functor1" << std::endl;
	}
};
 
struct functor2 : functor_base
{
	virtual void operator()() const
	{
		std::cout << "functor2" << std::endl;
	}
};
 
void foo(functor_base & functor)
{
	// No if's or function pointer.
	functor();
}
 
 
int main()
{
	foo(functor1());
	foo(functor2());
}

Select allOpen in new window

>> Rather than using function pointer I'd use polymorphic functors.

The "issue" with compiler optimizations (branch prediction etc.) is similar to when using function pointers though.

>> The "issue" with compiler optimizations (branch prediction etc.) is similar to when using function pointers though.
I wasn't suggesting I'd do it that way for optimization (see my comment above about premature optimization) I was suggesting I'd do it that way as I believe it'd make the code cleaner.

I know ;) Just making sure there are no misunderstandings for Unimatrix_001. Might also be because I'm very tired but don't want to sleep, so I'm trying to keep myself busy by just posting whatever comes up in my mind. Maybe I should just go to bed and get it over with ... heh ... think I'll do that.

>> Just making sure there are no misunderstandings for Unimatrix_001
No worries :)

>> Rather than using function pointer I'd use polymorphic functors.
I meant to point out last night (but like I8 I really should have gone to bed earlier)...

If performance of the dynamic polymorphic approach proves to be unacceptable you can always change it, quite simply, to use static polymorphism. This will avoid the use of the virtual functions (which are usually implemented as function pointers held in a v-table) but at the cost of a bigger exe and slower compile times (since templates will need to be instantiated for each functor). I'd go with the dynamic approach first and profile it and only change it if you feel it is necessary.

#include <iostream>
 
struct functor1
{
	virtual void operator()() const
	{
		std::cout << "functor1" << std::endl;
	}
};
 
struct functor2
{
	virtual void operator()() const
	{
		std::cout << "functor2" << std::endl;
	}
};
 
template <typename funcT>
void foo(funcT & functor)
{
	// No if's or function pointer.
	functor();
}
 
 
int main()
{
	foo(functor1());
	foo(functor2());
}

Select allOpen in new window

^^^ oops, I forgot to remove the virtual keyword (I've just woken up -- tsk!) :)

#include <iostream>
 
struct functor1
{
	void operator()() const
	{
		std::cout << "functor1" << std::endl;
	}
};
 
struct functor2
{
	void operator()() const
	{
		std::cout << "functor2" << std::endl;
	}
};
 
template <typename funcT>
void foo(funcT & functor)
{
	// No if's or function pointer.
	functor();
}
 
 
int main()
{
	foo(functor1());
	foo(functor2());
}

Select allOpen in new window

Hehehe - cheers for the extra info lads. Much appreciated...

>>(I've just woken up -- tsk!) :)
Ah, it's Saturday though. ;)

Uni

No worries Uri... good luck ;)