How to Wrap a Function with Variable Length Arguments

How can I wrap a function with variable length arguments?

The problem is that you cannot use 'printf' with va_args. You must use vprintf if you are using variable argument lists. vprint, vsprintf, vfprintf, etc. (there are also 'safe' versions in Microsoft's C runtime that will prevent buffer overruns, etc.)

You sample works as follows:

void myprintf(char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    vprintf(fmt, args);
    va_end(args);
}

int _tmain(int argc, _TCHAR* argv[])
{
    int a = 9;
    int b = 10;
    char v = 'C';
    myprintf("This is a number: %d and \nthis is a character: %c and \n another number: %d\n", a, v, b);
    return 0;
}

Wrapping a variable-length-arguments function in AS

I'm not aware of sprintf in AS3, but perhaps you're using a custom function... Try using Function.apply. I haven't tested this, but something like:

private function getString(name:String, ...args):String {
     return sprintf.apply(this, [xxx.getString(name)].concat(args));
}

How to create a variadic (with variable length argument list) function wrapper in JavaScript

Just use apply(). And for your antiquated execution engines, just do this

if ( 'undefined' == typeof Function.prototype.apply )
{
  Function.prototype.apply = function( context, args )
  {
    // whatever hacky way you want to implement it - i guess eval.
  }
}

Wrapping a functions taking a variable number of arguments using a decorator

Python has two variable argument variables: *args and **kwargs. args is a list of arguments specified without names (e.g. func(1,2,3)), while kwargs is a dictionary of arguments with names (e.g. func(x=1, y=2, z=3)).

Your code is only accepting the kwargs, so you also need to add the unnamed args:

def dec(function):
    def _wrapper(*args, **kwargs):
        print len(args) + len(kwargs)
        return function(*args, **kwargs)
    return _wrapper

How to use variadic templates to wrap a variable number of function arguments?

The technical term is parameter packs.

And it should as "easy" as

template<typename... T>
void f(T... args)
{
    g(Wrapper<T>(args)...);
}

Of course, it requires you to have the proper g function.

Creating a function with variable-length arguments python

You can append the cumulative sums to a separate list for output, so that you can use index -1 to access to preceding cumulative sum:

def simple_tuple_func(*args):
    cumulative_sums = []
    for i in args:
        cumulative_sums.append((cumulative_sums[-1] if cumulative_sums else 0) + i)
    return tuple(cumulative_sums)

so that:

simple_tuple_func(1,2,3)

would return:

(1, 3, 6)

Wrap macro with variable number of arguments

wrap macro with variable number of arguments

It simply is not possible to "expand" a valist to a variable number of arguments and pass those to a variadic functions on run-time, at least not with any additional helpers (which are not part of C and are not portable and might not be available for you implementation/platform).

gDbgLog() expects getting each argument passed separately:

gDbgLog("%s %d", "hello, world", 42);

What the code you show does instead is passing exactly one parameter as the __VA_ARGS__ part, namely the value of valist.

gDbgLog(fmt,args);

---

How to solve this?

dbgLog() wraps vsnprintf() to generate the output.

So just drop gDbgLog() and call vsnprintf() from pMonDbgLog() directly passing the valist as initialised by the code snippet you show.

wrapper for a function with variable arguments in C

If you just want to use this to prepend an string to the output or so, you could use a variadic macro.

#define MYPRINT(...) printf("toto has: " __VA_ARGS__)

in that simple example this suppposes that format that you pass in is a string literal, so this is a bit restricted. But I hope you see the pattern how to use such simple macro wrappers.

Trying to wrap my head around variable input arguments in python functions

If you want to work with multiple arguments, you can try this:

def covers(*args):

    mydict = dict()

    for arg in args:
        mylist = list()

        for k, v in COURSES.items():
            if arg in v:
                mylist.append(k)

        mydict[arg] = mylist

    return mydict

Using dict and list comprehensions, you can make this shorter:

def covers(*args):
    return {arg: [k for k, v in COURSES.items() if arg in v] for arg in args}

This produces a dictionary with an entry for every string you provide. The value of the entry is a list with all the matching courses. So if you call it like this:

covers('variables', 'Python')

You get the following dict:

{'variables': ['PHP Basics', 'Java Basics', 'Python Basics'], 'Python': ['Python Basics']}

Concerning your problems with multiple arguments: *args catches all positional arguments in a list that are not explicitly declared in the function definition and **kwargs similarly catches all keyword arguments in a dict. So by defining only *args as function argument, all arguments from the function call are stored as list, which can be iterated as usual.

---

Related Topics