5

I want to forward calls to a library which has a variadic method. The simplest example I could come up with to replicate the problem is this:

void Bar(int useless, ...)
{
  //Does something
}

template<typename... Args>
void Foo(int useless, Args... args)
{
  Bar(useless, args...);
}

As you can see, I have had a go. However, even though this compiles, it seems to cause the stack to have a wobbler and I see errors on application exit. I can understand from the compilers point of view that this solution is problematic.

I am unsure how to get this working, or whether it is even possible to get this working. I have seen some people suggest using the "indices trick" in similar situations but I have not been able to get it working on this particular occasion.

Any help appreciated!

ChrisWard1000
  • 526
  • 5
  • 15
  • 2
    the C version for variables arguments is very limited and it might be the case where args from `Foo` are passed to `bar` and retrieved with incorrect types. See http://stackoverflow.com/questions/15026671/c-variable-argument-list – Raxvan Dec 04 '13 at 15:59
  • 3
    Can you provide a full sample that produces errors? msvc, clang and gcc compiled versions seem to run fine for me. – melak47 Dec 04 '13 at 16:05
  • 2
    This will work for trivially-copyable types (assuming `Bar` has some means to determine their type); other types can't be passed through `...` at all, and there's nothing you can do to fix that. – Mike Seymour Dec 04 '13 at 16:13

1 Answers1

9

The approach you are taking is very sane, safe and sound by itself. For example, the below program is using variadic template arguments and forwards them to std::printf(), which is a C-style function that accepts variable number of arguments:

#include <utility>
#include <cstdio>

template <unsigned int S, typename ...T>
void my_printf(const char (&fmt)[S], T&&... args) {
    std::printf(fmt, std::forward<T>(args)...);
}

int main(int argc, const char* argv[]) {
    my_printf("Hello, %s!\n", "World!");
    my_printf("I will count to %u...\n", 10);
    for (int i = 0; i < 10; ++i)
        my_printf("%s %s %u\n", "...", "and", i + 1);
    my_printf("And here are my arguments :)\n");
    for (int i = 0; i < argc; ++i)
        my_printf("argv[%u] == %s\n", i, argv[i]);
}

The problem with undefined behavior and possibly stack corruption is caused by something else. In C++, this is most likely caused by passing non-POD types though C's variable argument list (i.e. passing std::string to printf() can do this).

Unfortunately, compiler extensions like "format attribute" won't help here. But compiler might warn you about non-POD types. For example, call my_printf() with std::string and you will be rewarded with a warning similar to this:

./test.cc:7:46: error: cannot pass objects of non-trivially-copyable type ‘class std::basic_string<char>’ through ‘...’
     std::printf(fmt, std::forward<T>(args)...);

                                          ^

Of course, there could be something else going on that compiler won't be able to catch for you. Unfortunately, there is no better way than to debug your program and see what exactly is causing it to crash.

Since you are entering dark waters of C and unsafe arguments passing, debugger is your friend here, and I'd also recommend you use Valgrind - it is very helpful catching things like that.

Hope it helps. Good Luck!