variadic-functions

Possible Duplicate: Why does Guava's ImmutableList have so many overloaded of() methods? Looking at Guava's ImmutableList (and some other classes), you'll find plenty of overloaded of convenience methods ("Returns an immutable list containing the given elements, in order.") that take a different number of parameters: ... public static <E> ImmutableList<E> of(E e1, E e2, E e3) public static <E> ImmutableList<E> of(E e1, E e2, E e3, E e4) public static <E> ImmutableList<E> of(E e1, E e2, E e3, E e4, E e5) ... All the way to this one: public static <E> ImmutableList<E> of(E e1, E e2, E e3, E e4,

I play with C++0x for some time and now I want to use variadic templates and tuple to implement class "Task". I'm going to pass Task objects into newly created threads (using pthread). Task class will contain function pointer to function which should be called inside thread and arguments for this function, simplified code: class TaskCaller { // ... virtual bool dispatch (void); }; template<typename ...T_arguments> Task : public TaskCaller { public: // ... Task (bool (*function) (T_arguments&...), T_arguments... arguments) : function_arguments_tuple (arguments...), function (function) { // ...

I'm implementing an API an have a method which you pass a list of paths where the program reads resources from public void importFrom(String... paths) { } I'm using varargs to make calling the method as convenient as possible to the user, like so obj.importFrom("/foo", "/foo/bar); Is this an appropriate use of varargs? Or is passing in an array better? In your case varargs is just fine. You don't really need to make an array of the paths that you will be importing because there's nothing you want to do with these paths other than to pass them along to your importFrom method. The varargs

I have the following function: void doStuff(int unusedParameter, ...) { va_list params; va_start(params, unusedParameter); /* ... */ va_end(params); } As part of a refactor, I'd like to remove the unused parameter without otherwise changing the implementation of the function. As far as I can tell, it's impossible to use va_start when you don't have a last non-variadic parameter to refer to. Is there any way around this? Background: It is in fact a C++ program, so I could use some operator-overloading magic as suggested here , but I was hoping not to have to change the interface at this point.

Consider the following C program: #include <stdio.h> #include <stdarg.h> typedef void (callptr)(); static void fixed(void *something, double val) { printf("%f\n", val); } static void dynamic(void *something, ...) { va_list args; va_start(args, something); double arg = va_arg(args, double); printf("%f\n", arg); } int main() { double x = 1337.1337; callptr *dynamic_func = (callptr *) &dynamic; dynamic_func(NULL, x); callptr *fixed_func = (callptr *) &fixed; fixed_func(NULL, x); printf("%f\n", x); } Basically, the idea is to store a function with variable arguments in a "generic" function pointer

I'm trying to write a variadic template constexpr function which calculates sum of the template parameters given. Here's my code: template<int First, int... Rest> constexpr int f() { return First + f<Rest...>(); } template<int First> constexpr int f() { return First; } int main() { f<1, 2, 3>(); return 0; } Unfortunately, it does not compile reporting an error message error C2668: 'f': ambiguous call to overloaded function while trying to resolve f<3,>() call. I also tried to change my recursion base case to accept 0 template arguments instead of 1: template<> constexpr int f() { return 0; }