Replace C varargs with modern C++ equivalent construct

Question

I am attempting to rewrite old C code in its C++ equivalent. The module i am working on seem to use C variable arguments list alot. One of the common usage example is as follows (PLEASE NOTE THAT BELOW CODE IS JUST INDICATIVE EXAMPLE, its not actual production code. MY INTENTION IS TO REWRITE THE USAGE OF VARARGS with Modern C++ constructs) :

#include <stdio.h>
#include <stdarg.h>
 
void simple_printf(const char* fmt, ...)
{
    va_list args;
    va_start(args, fmt);
 
    while (*fmt != '\0') {
        if (*fmt == 'd') {
            int i = va_arg(args, int);
            printf("%d\n", i);
        } else if (*fmt == 'c') {
            // A 'char' variable will be promoted to 'int'
            // A character literal in C is already 'int' by itself
            int c = va_arg(args, int);
            printf("%c\n", c);
        } else if (*fmt == 'f') {
            double d = va_arg(args, double);
            printf("%f\n", d);
        }
        ++fmt;
    }
 
    va_end(args);
}
 
int main(void)
{
    simple_printf("dcff", 3, 'a', 1.999, 42.5); 
}

I am interested in knowing what are the alternatives available in Modern C++ to rewrite this code something similar as above. I am also interested in knowing multiple options available in Modern C++. A code example will be more beneficial.

Reference: https://en.cppreference.com/w/cpp/language/parameter_pack — YZ_SO, Dec 05 '22 at 01:40
varargs give you variable resolution at runtime of compile-time types. The C++ equivalent would be templates, but it can get hairy. — JohnFilleau, Dec 05 '22 at 01:42

bolov · Accepted Answer · 2022-12-05T18:13:37.910

7

The only thing "special" that this function does it puts a newline after each arguments. In c++17 you can do that with fold expression:

template<typename... Args>
void print(Args... args) {
    ((std::cout << args << '\n'), ...); 
}

In older versions you can do it with recursion:

template<typename T>
void print(T value) {
  std::cout << value << std::endl;
}

template<typename T, typename... Args>
void print(T value, Args... args) {
  print(value);
  print(args...);
}

Anyway this is a bit odd. Modern C++ would use format. Either the fmt library or the C++20 standard format library:

std::cout << std::format("{}\n{}\n{}\n{}\n", 3, 'a', 1.999, 42.5);

And in C++23:

std::print("{}\n{}\n{}\n{}\n", 3, 'a', 1.999, 42.5);

edited Dec 05 '22 at 18:13

answered Dec 05 '22 at 02:06

bolov

72,283
15
145
224

You don't need to pass `std::cout` to `std::print`, it'll go to `stdout` by default. – Barry Dec 05 '22 at 15:58
@Barry oh, I missed that in the docs. Thank you! – bolov Dec 05 '22 at 18:14

score 1 · Answer 2 · answered Dec 05 '22 at 01:47

You can get rid of this function completely. Throw it away. Hit the "Delete" button.

simple_printf("dcff", 3, 'a', 1.999, 42.5);

In C++ this becomes:

std::cout << 3 << "\n" << 'a' << "\n" << 1.999 << "\n" << 42.5 << "\n";

No function is necessary. And, this is even safer than the C version, which you could still misuse by giving the wrong formatting string. The C++ version is bulletproof.

And this isn't exactly "modern" C++. You could've done that right from the beginning, pretty much.

I suppose you can replace this with a template function, to add a newline automatically, but this would be overkill. This is simple enough without adding this kind of complexity.

While not commenting on the safety of the code, I will comment on the length of the code. It appears to me that many "modern" constructs are actually longer than the old C constructs that they aspire to replace. In your example, the C++ equivalent is nearly twice as long (and hence takes twice as long to type out) unless one uses some sort of auto snippets engine -- but snippets management itself could be nontrivial with so many variations possible thereof. — Tryer, Dec 05 '22 at 03:10

Replace C varargs with modern C++ equivalent construct

2 Answers2