Is it better (performance …) to pass parameters as array
template<typename Number>
static int solveQuadraticFunction(Number* dst, const Number* src)
{
Number a=src[0], b=src[1], c=src[2];
// …
}
or the "standard" way
template<typename Number>
static int solveQuadraticFunction(Number* dst, Number a, Number b, Number c)
{
// …
}
Probably not.
It depends on the arrangement of the arguments before the call. In the former case, you're requiring that the arguments be arranged into an array before the call, which might already be the case, or it might not; if it is already the case, and there are a large number of arguments, then it may be more optimal simply because it doesn't require the values to be assembled on the stack. However, it might result on the values simply being copied from the array onto the stack inside the called function instead of outside it, depending on how you then access the arguments (the specific example you give looks problematic: you define local variables and assign them from array elements; local variables typically live on the stack, though the compiler may be able to optimize them away).
Of course if the argument are not already arranged in an array before the call, then there is no gain (and there is probably at least a slight penalty) because you have to find somewhere to store the arguments as an array - which might involve memory allocation/deallocation - and then the arguments must be accessed indirectly via a pointer, which also has a slight cost.
I doubt you'll see any difference in performance; given appropriate optimization settings and inlining, the compiler should be able to decide which one to use.
The second option should be preferred when there's a small number of arguments, since it allows the compiler to check the number of items passed in.
(But concerning your example, be sure to use references: Number const &a=src[0], &b=src[1], &c=src[2]. These will be optimized away by any half-decent compiler.)
You will be pushing 2 more variables onto the stack when you call the second method than the first.
But it probably makes very little difference unless this was running in a very tight loop.
This depends on many things and is of course hardware/platform-dependent. In general, for many parameters (> 4) the array method is probably more efficient. If the parameter type doesn't fit into a CPU register, passing as an array should always be more efficient.
Ofcourse it's better to pass the address of the first element rather than pushing all the elements. You can either pass the pointer or the array by reference as below:
template<typename Number, unsigned int SIZE>
static int solveQuadraticFunction(Number* dst, Number (&src)[SIZE])
{
// … src is passed by reference
}
