Perfect Forwarding and Return Values

Perfect forwarding with std::forward() is primarily used to forward function arguments while preserving their value category and const-ness. However, it is not typically used to forward return values from a function.

When a function returns a value, the return value is either an rvalue or an lvalue reference, depending on the return type of the function. The value category of the return value is determined by the return type and is not influenced by how the returned object is obtained within the function.

Here's an example to illustrate this:

1#include <iostream>
2#include <utility>
3
4int& get_lvalue_ref() {
5  static int x = 10;
6  return x;
7}
8
9int get_rvalue() { return 20; }
10
11template <typename T>
12T&& forward_value(T&& value) {
13  return std::forward<T>(value);
14}
15
16int main() {
17  int& lvalue_ref = get_lvalue_ref();
18  int rvalue = get_rvalue();
19
20  int& forwarded_lvalue_ref =
21    forward_value(lvalue_ref);
22  int forwarded_rvalue =
23    forward_value(rvalue);
24
25  std::cout << "lvalue_ref: "
26    << lvalue_ref << "\n";
27  std::cout << "rvalue: "
28    << rvalue << "\n";
29  std::cout << "forwarded_lvalue_ref: "
30    << forwarded_lvalue_ref << "\n";
31  std::cout << "forwarded_rvalue: "
32    << forwarded_rvalue << "\n";
33}

1lvalue_ref: 10
2rvalue: 20
3forwarded_lvalue_ref: 10
4forwarded_rvalue: 20

In this example, get_lvalue_ref() returns an lvalue reference to a static variable x, while get_rvalue() returns an rvalue.

The forward_value() function template takes a forwarding reference value and uses std::forward<T>(value) to forward the value. However, the return type of forward_value() is T&&, which is a forwarding reference.

When forward_value() is called with lvalue_ref(), which is an lvalue reference, the returned value is still an lvalue reference. Similarly, when forward_value() is called with rvalue, which is an rvalue, the returned value is still an rvalue.

The output of the program demonstrates that the value category of the return value is determined by the return type of the function (get_lvalue_ref() and get_rvalue()) and is not affected by the use of std::forward() in forward_value().

In general, perfect forwarding with std::forward() is not necessary or beneficial for forwarding return values. The value category of the return value is already determined by the return type of the function, and using std::forward() does not provide any additional advantages in this context.