Tell us about prefix forwarding (perfect forwarding)…

Perfect forwarding in C++ allows passing function arguments to another function while preserving their value categories (lvalue or rvalue) and const/volatile qualifiers.

This is achieved through a combination of two mechanisms:

Function templates: A function using perfect forwarding must be a template.
Universal references: Parameters of such a template function are declared as T&&. Depending on whether the argument is an lvalue or rvalue, T will be deduced as the argument's type (for rvalue) or as a reference to the argument's type (for lvalue).
std::forward<T>(): This template function is used to cast the argument param with type T&& to the appropriate type. If T is a reference type, std::forward<T>(param) returns an lvalue reference. If T is a non-reference type, it returns an rvalue reference or lvalue depending on the context.

Example usage:

#include <utility> // For std::forward

void process_value(int& value) {
    // Handling lvalue
}

void process_value(int&& value) {
    // Handling rvalue
}

template <typename T>
void forward_to_process(T&& arg) {
    // perfect forwarding
    process_value(std::forward<T>(arg));
}

int main() {
    int val = 42;
    forward_to_process(val);       // Passing lvalue
    forward_to_process(100);       // Passing rvalue
    return 0;
}

In this example, forward_to_process is a template function capable of accepting both lvalue and rvalue ints. std::forward<T>(arg) ensures that the call to process_value matches the value category of arg.

Perfect forwarding is especially useful when creating wrappers around other functions or when passing arguments to constructors in patterns like factories or object pools. It helps avoid unnecessary temporary objects or copies and maintains efficiency when working with move semantics.

Tell us about prefix forwarding (perfect forwarding) in C++.