Perfect Forwarding and Move-Only Types

Perfect forwarding with std::forward() is particularly useful when dealing with move-only types, such as unique pointers (std::unique_ptr) or types with move-only semantics. Move-only types cannot be copied, but they can be moved efficiently.

Here's an example that demonstrates how perfect forwarding with std::forward() handles move-only types:

1#include <iostream>
2#include <memory>
3#include <utility>
4
5void process_data(std::unique_ptr<int> ptr) {
6  if (ptr) {
7    std::cout << "Value: " << *ptr << "\n";
8  } else {
9    std::cout << "Null pointer\n";
10  }
11}
12
13template <typename T>
14void forward_data(T&& arg) {
15  process_data(std::forward<T>(arg));
16}
17
18int main() {
19  auto ptr = std::make_unique<int>(42);
20
21  forward_data(std::move(ptr));
22
23  if (ptr) {
24    std::cout << "ptr still valid\n";
25  } else {
26    std::cout << "ptr moved\n";
27  }
28}

1Value: 42
2ptr moved

In this example, process_data() is a function that takes a std::unique_ptr<int> as an argument. The forward_data() function template takes a forwarding reference arg of type T&& and forwards it to process_data() using std::forward<T>(arg).

In the main function, a std::unique_ptr<int> named ptr is created with a value of 42. The forward_data() function is called with std::move(ptr), which indicates that ptr can be moved.

Inside forward_data(), std::forward<T>(arg) is used to forward the argument to process_data(). In this case, T is deduced as std::unique_ptr<int>, and std::forward<std::unique_ptr<int>>(arg) is used to forward the unique pointer as an rvalue.

When process_data() receives the forwarded unique pointer, it takes ownership of the pointer. If the pointer is valid (i.e., not null), it prints the value pointed to by the unique pointer.

After calling forward_data(), the original ptr is checked. Since the unique pointer was moved using std::move() and then perfectly forwarded, ptr is now in a moved-from state and evaluates to false. This is indicated by the output "ptr moved".

Perfect forwarding with std::forward() allows move-only types, such as std::unique_ptr, to be efficiently forwarded as rvalues. This enables the receiving function to take ownership of the move-only object and avoids unnecessary copies.

By using perfect forwarding, you can write generic code that seamlessly handles move-only types, ensuring efficient resource management and optimal performance.