variadic | Go library for interfacing with variadic C functions

Off Topic Suggestion: don't use, when you can, C-styles arrays but C++ std::array.

For example: the following line

You can use template partial specialization to get ARGS:

In C++11 and newer you can use template parameter packs to create a recursive implementation, like this:

You can do it like this:

The method you are trying to invoke is declared as get(String first, String... more). The variadic syntax in Java is just sugar for an array of the specified type, i.e. the two arguments of this method are really String and String[] -- which you correctly coded in the GetStaticMethodID call as (Ljava/lang/String;[Ljava/lang/String;).

So to call it you need two arguments: one String and one String[] (array) -- and (for your case) the array must contain zero elements, but such an empty array is not the same as NULL. Have a gander at NewObjectArray.

You can define a helper function to use index_sequence to expand the elements of Tuple and assign values through fold expression.

I think this might be an instance of the TypeScript design limitation reported in microsoft/TypeScript#41164. As mentioned there,

Certain circularities are allowed [...] but other circularities aren't, e.g.

In general, no. The rules of C++ explicitly allow implicit conversions to take place. The fact that the authors of C++ made some of those conversions potentially unsafe is another matter.

You could add std::is_constructible static_assert or SFINAE to the code to make the compiler errors less ugly if the user inputs wrong arguments, but it won't solve implicit conversions.

From design perspective, the code should not care about this, the purpose of emplace_XXX is to allow exactly the calls that are allowed for T{args...}.

Note: You most likely want to forward the arguments like T element{std::forward(args)...}; and also move the element into the vector vec.push_back(std::move(t));.

Rather than trying to deduce TDependencies directly from the pFactory parameter type, I'd write a type trait to get the dependencies from the whole parameter pack instead. With boost::mp11: