Capturing Lvalues and Rvalues in Variadic Functions

To write a variadic function that can accept both lvalue and rvalue arguments, you can use forwarding references (also known as universal references) in the parameter pack. Forwarding references are declared using the && syntax with a deduced type (auto or template type parameter).

Here's an example:

1#include <iostream>
2
3// Variadic function using forwarding references
4template <typename... Types>
5void PrintValues(Types&&... Args) {
6  (std::cout << ... << std::forward<Types>(Args))
7    << '\n';  
8}
9
10int main() {
11  int a = 10;
12  const std::string b = "hello";
13  
14  // lvalues
15  PrintValues(a, b);
16
17  // rvalues
18  PrintValues(20, std::string("world"));
19}

110hello
220world

In this example, PrintValues() uses forwarding references Types&&... Args to capture both lvalue and rvalue arguments. Inside the function, std::forward<Types>(Args) is used to forward the arguments to std::cout while preserving their value category.

When PrintValues() is called with lvalue arguments a and b, the compiler deduces the template arguments as int& and const std::string& respectively. The arguments are forwarded as lvalue references.

When PrintValues() is called with rvalue arguments 20 and std::string("world"), the compiler deduces the template arguments as int&& and std::string&& respectively. The arguments are forwarded as rvalue references.

By using forwarding references, the variadic function can accept and forward both lvalue and rvalue arguments, avoiding unnecessary copying and enabling perfect forwarding.

It's important to note that if you don't need to modify the arguments and want to avoid potential dangling references, you can use const Types&... instead of Types&&... to capture lvalues and rvalues as const references.

1template <typename... Types>
2void PrintValuesConstRef(const Types&... Args) {
3  (std::cout << ... << Args) << '\n';
4}

This version captures both lvalues and rvalues as const references, preventing modification and avoiding dangling references, but it does not enable perfect forwarding.