variadic-functions

I'd like to implement a function with both generics and varargs. public class Question { public static <A> void doNastyThingsToClasses(Class<A> parent, Class<? extends A>... classes) { /*** something here ***/ } public static class NotQuestion { } public static class SomeQuestion extends Question { } public static void main(String[] args) { doNastyThingsToClasses(Object.class, Question.class, SomeQuestion.class); // OK doNastyThingsToClasses(Question.class, SomeQuestion.class); // OK doNastyThingsToClasses(Question.class, Object.class, SomeQuestion.class); // compilation failure } } The

Varargs: public static void foo(String... string_array) { ... } versus Single array param: public static void bar(String[] string_array) { ... } Java 1.6 seems to accept/reject the following: String[] arr = {"abc", "def", "ghi"}; foo(arr); // accept bar(arr); // accept foo("abc", "def", "ghi"); // accept bar("abc", "def", "ghi"); // reject Assuming the above is true/correct, why not always use varargs instead of single array param? Seems to add a touch of caller flexiblity for free. Can an expert share the internal JVM difference, if there is one? Thanks. Arrays have been around from the

How can I get a count of the number of arguments to a variadic template function? ie: template<typename... T> void f(const T&... t) { int n = number_of_args(t); ... } What is the best way to implement number_of_args in the above? Nawaz Just write this: const std::size_t n = sizeof...(T); //you may use `constexpr` instead of `const` Note that n is a constant expression (i.e known at compile-time), which means you may use it where constant expression is needed, such as: std::array<int, n> a; //array of n elements std::array<int, 2*n> b; //array of (2*n) elements auto middle = std::get<n/2>

I know I can use va_arg to write my own variadic functions, but how do variadic functions work under the hood, i.e. on the assembly instruction level? E.g., how is it possible that printf takes a variable number of arguments? * No rule without exception. There is no language C/C++, however, this question can be answered for both of them * Note: Answer originally given to How can printf function can take variable parameters in number while output them? , but it seems it did not apply to the questioner Sebastian Mach The C and C++ standard do not have any requirement on how it has to work. A

Haskell's type safety is second to none only to dependently-typed languages. But there is some deep magic going on with Text.Printf that seems rather type-wonky. > printf "%d\n" 3 3 > printf "%s %f %d" "foo" 3.3 3 foo 3.3 3 What is the deep magic behind this? How can the Text.Printf.printf function take variadic arguments like this? What is the general technique used to allow for variadic arguments in Haskell, and how does it work? (Side note: some type safety is apparently lost when using this technique.) > :t printf "%d\n" "foo" printf "%d\n" "foo" :: (PrintfType ([Char] -> t)) => t The

I've recently come across the java @SafeVarargs annotation. Googling for what makes a variadic function in Java unsafe left me rather confused (heap poisoning? erased types?), so I'd like to know a few things: What makes a variadic Java function unsafe in the @SafeVarargs sense (preferably explained in the form of an in-depth example)? Why is this annotation left to the discretion of the programmer? Isn't this something the compiler should be able to check? Is there some standard one must adhere to in order to ensure his function is indeed varags safe? If not, what are the best practices to