How to call a function on all variadic template args?

by

C++17 fold expression

(f(args), ...);

If you call something that might return an object with overloaded comma operator use:

((void)f(args), ...);

Pre-C++17 solution

The typical approach here is to use a dumb list-initializer and do the expansion inside it:

{ print(Args)... }

Order of evaluation is guaranteed left-to-right in curly initialisers.

But print returns void so we need to work around that. Let’s make it an int then.

{ (print(Args), 0)... }

This won’t work as a statement directly, though. We need to give it a type.

using expand_type = int[];
expand_type{ (print(Args), 0)... };

This works as long as there is always one element in the Args pack. Zero-sized arrays are not valid, but we can work around that by making it always have at least one element.

expand_type{ 0, (print(Args), 0)... };

We can make this pattern reusable with a macro.

namespace so {
    using expand_type = int[];
}

#define SO_EXPAND_SIDE_EFFECTS(PATTERN) ::so::expand_type{ 0, ((PATTERN), 0)... }

// usage
SO_EXPAND_SIDE_EFFECTS(print(Args));

However, making this reusable requires a bit more attention to some details. We don’t want overloaded comma operators to be used here. Comma cannot be overloaded with one of the arguments void, so let’s take advantage of that.

#define SO_EXPAND_SIDE_EFFECTS(PATTERN) \
        ::so::expand_type{ 0, ((PATTERN), void(), 0)... }

If you are paranoid afraid of the compiler allocating large arrays of zeros for naught, you can use some other type that can be list-initialised like that but stores nothing.

namespace so {
    struct expand_type {
        template <typename... T>
        expand_type(T&&...) {}
    };
}

More Related Contents:

  1. “unpacking” a tuple to call a matching function pointer
  2. make_unique and perfect forwarding
  3. Variadic template pack expansion
  4. How do I get the argument types of a function pointer in a variadic template class?
  5. C++11: I can go from multiple args to tuple, but can I go from tuple to multiple args? [duplicate]
  6. What are the rules for the “…” token in the context of variadic templates?
  7. check variadic templates parameters for uniqueness
  8. Check at Compile-Time if Template Argument is void
  9. How to make generic computations over heterogeneous argument packs of a variadic template function?
  10. What is the meaning of “… …” token? i.e. double ellipsis operator on parameter pack
  11. Is it possible to “store” a template parameter pack without expanding it?
  12. How to create the Cartesian product of a type list?
  13. Parameter pack must be at the end of the parameter list… When and why?
  14. How to reverse the order of arguments of a variadic template function?
  15. What does this variadic template code do?
  16. Can someone please explain the “indices trick”?
  17. effective way to select last parameter of variadic template
  18. Expansion with variadic templates [duplicate]
  19. C++ parameter pack, constrained to have instances of a single type?
  20. C++11 “overloaded lambda” with variadic template and variable capture
  21. Check traits for all variadic template arguments
  22. How can I have multiple parameter packs in a variadic template?
  23. How can I expand call to variadic template base classes?
  24. C++11: Number of Variadic Template Function Parameters?
  25. How to make a variadic is_same?
  26. generic member function pointer as a template parameter
  27. how to avoid undefined execution order for the constructors when using std::make_tuple
  28. Generating one class member per variadic template argument
  29. template parameter packs access Nth type and Nth element
  30. using declaration in variadic template

Leave a Comment