MATLAB: Which way to call function is better

functioninput argumentsMATLAB

I have more than hundred of input parameters in myfunc and I am using the following way to call the function after grouping the parameters in the cell array C. 
C = {a,b,c};
d = myfunc(C{:});
function d = myfunc(a,b,c)
d = a * b + c; 
end
I am wondering wether the following way is better or not
C = {a,b,c};
d = myfunc(C);
function d = myfunc(C)
[a,b,c] = C{:};
d = a * b + c;
end

Best Answer

Neither way is "better". Both feel just a little clumsy, since I'm not sure why you feel the need to package the variables together in a cell array at all.
The first form seems a bit cleaner in my eye, perhaps closer to traditional MATLAB.
The latter form seems like it does not require the function to have a fixed number of input arguments. So arguably, there could be some elegance in the second one too. But then, the very first thing you needed to do was to unpack the arguments [a,b,c] into a fixed set of variables. So any elegance that seemed to be there is imediately gone.
Neither method will be more efficient. In both cases, you create a cell array, then unpack the cell array into a comma separated list via C{:}. So you're doing exactly the same thing, except that in one case, the comma separated list happens outside the function call, and in the other, the list creation happens inside the function.
Again, as I said, both forms seem a bit of a clumsy way to code. If you absolutely feel the need to use one of them, pick the one that makes you more happy.
Edit: I see that you have a hundred or so various parameters in your function, so you don't want to have a function call with a hundred input arguments. This seems to make some sense, that you don't want an extensive argument list.
In that case, a common approach is to pack the elements into a structure. Now you can access them directly as S.a, S.b, S.c, never needing to unpack them at all. But that makes more typing when you write your function, since you would need to attach the characters S. in front of each variable.
Of course, you could use tools like struct2cell to automatically unpack the struct. But that begs the question of why you wanted to created the struct as a package for your variables at all.
So, since you have a huge number of arguments, perhaps the second way seems simplest in the end. It allows you to not need to write a function header with that huge list of arguments.
Related Question