Simplifying work with variadic functions / macros

Question

I'm writing a bunch of functions like this:

template <>
Error SyntaxError<unfinished_string>(unsigned int line) {
    std::stringstream message;
    message << "SyntaxError: unfinished string (starting at line " << line << ").";
    return Error(Error::Type::syntax, message.str());
}

template <>
Error SyntaxError<malformed_number>(std::string number, unsigned int line) {
    std::stringstream message;
    message << "SyntaxError: malformed number (" << number << ") at line " << line << '.';
    return Error(Error::Type::Syntax, message.str());
}

...

And it wouldn't be bad to have a variadic function / macro that looked something like this:

Error proto(/*variable number & type of arguments*/) {
    std::stringstream message;
    message << "SyntaxError: " << /*arguments passed, separated by <<s */;
    return Error(Error::Type::syntax, message.str());
}

So that I could then write my functions as:

template <>
Error SyntaxError<unfinished_string>(unsigned int line) {
    return proto("unfinished string (starting at line ", line, ").");
}

template <>
Error SyntaxError<malformed_number>(std::string number, unsigned int line) {
    return proto("malformed number (", number, ") at line ", line, '.');
}

Is that by any chance possible? How if yes?

Not sure why people are voting to close. The answer is yes. I'll put together a real answer in a second. — xaxxon, Oct 18 '16 at 15:20
How many versions do you need? Can you add more constructors to `Error`? Like [`std::system_error`](http://en.cppreference.com/w/cpp/error/system_error/system_error) does. — Bo Persson, Oct 18 '16 at 15:20

score 1 · Accepted Answer · edited Oct 18 '16 at 15:35

If you want to convert a variadic list of arguments and stream them altogether, then you could implement an additional function that recursively appends each argument to that stream. Example:

template< typename FirstArg, typename... Args >
inline std::ostream& join_args( std::ostream& os, FirstArg arg, Args... args ) {
   os << arg;
   return join_args( os, args... );
}

Step by step, you will be exhausting the arguments. Take care of the order you process it, ( std::ostream& os, FirstArg arg, Args... args ) is not the same as ( std::ostream& os, Args... args, LastArg arg ).

Last but not least, you should cover the corner cases (either one or no arguments, depending on your problem):

inline std::ostream& join_args( std::ostream& os ) {
   return os;
}

Don't worry about recursion efficiency, the compiler will be able to inline all the function calls (as it knows at compile time how deep the recursion is) and flatten all the code, so that the resulting program would be more or less equivalent to manually appending all the arguments into a single stream.

`return join_args( args... );` shouldn't it pass `os` as the first argument (i.e. `join_args(os, args...)`)? — user6245072, Oct 18 '16 at 15:26
Definitely user6245072, I just draft coded it and forgot to review those errors. Thanks! — Jorge Bellon, Oct 18 '16 at 15:35

Simplifying work with variadic functions / macros

1 Answers1