Encaminhamento Perfeito

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy. Lição 84 de 104.

Ao escrever funções de modelo que aceitam argumentos e os passam para outras funções, surge um problema: como preservar se o argumento original era um lvalue ou um rvalue? O encaminhamento perfeito resolve isso passando os argumentos exatamente como foram recebidos, mantendo sua categoria de valor.

Os ingredientes principais são referências de encaminhamento (escritas como T&& em um contexto de template) e std::forward. Uma referência de encaminhamento pode ser associada tanto a lvalues quanto a rvalues, e std::forward converte condicionalmente o argumento de volta para seu tipo original:

#include <iostream>
#include <utility>

void process(int& x) { std::cout << "lvalue: " << x << "\n"; }
void process(int&& x) { std::cout << "rvalue: " << x << "\n"; }

template<typename T>
void wrapper(T&& arg) {
    process(std::forward<T>(arg));
}

int main() {
    int n = 10;
    wrapper(n);       // Chama process(int&) - lvalue preservado
    wrapper(20);      // Chama process(int&&) - rvalue preservado
}

Sem std::forward, os parâmetros nomeados são sempre lvalues dentro da função, mesmo que um rvalue tenha sido passado. Isso impediria que a semântica de movimento funcionasse corretamente ao encaminhar para construtores ou outras funções.

O encaminhamento perfeito é essencial para escrever funções de fábrica, classes wrapper e qualquer código genérico que precise construir objetos ou invocar funções, preservando a intenção do chamador quanto a mover em vez de copiar.

Desafio

Fácil

Vamos criar uma função fábrica que demonstra o encaminhamento perfeito construindo objetos enquanto preserva a categoria de valor dos argumentos passados a ela. Você criará uma função genérica make_object que encaminha os argumentos para um construtor de classe, garantindo que lvalues sejam copiados e rvalues sejam movidos.

Você organizará seu código em três arquivos:

Widget.h: Defina uma classe Widget que rastreie como recebe seus dados.
Seu Widget deve armazenar um nome std::string e um valor int. Forneça dois construtores:
- Um que aceite const std::string& (referência lvalue) e int: imprime Widget constructed (copy): [name]
- Um que aceite std::string&& (referência rvalue) e int: imprime Widget constructed (move): [name] e move a string
Adicione também um método display() que imprima [name]: [value].
Factory.h: Crie sua função fábrica com encaminhamento perfeito.
Escreva uma função de template make_object que aceite uma referência de encaminhamento para o nome e um int comum para o valor. Use std::forward para passar o argumento name ao construtor de Widget, preservando sua categoria de valor original.

A função deve retornar o Widget construído por valor.
main.cpp: Leia duas entradas:
1. Um nome (string)
2. Um valor (inteiro)
Demonstre o encaminhamento perfeito criando dois widgets:
1. Primeiro, armazene o nome em uma variável local e passe-o para make_object como um lvalue
2. Segundo, passe uma string temporária (o mesmo nome concatenado com "_temp") diretamente para make_object como um rvalue
Depois de criar cada widget, chame seu método display().

Por exemplo, com as entradas Gadget e 42:

Widget constructed (copy): Gadget
Gadget: 42
Widget constructed (move): Gadget_temp
Gadget_temp: 42

Com as entradas Device e 100:

Widget constructed (copy): Device
Device: 100
Widget constructed (move): Device_temp
Device_temp: 100

A principal ideia é que sua função make_object não sabe se recebeu um lvalue ou rvalue, mas, ao usar std::forward, preserva essa informação ao chamar o construtor de Widget. Isso permite que a resolução de sobrecarga do construtor selecione a versão apropriada, possibilitando movimentos eficientes para temporários e cópias seguras de variáveis nomeadas.

Experimente você mesmo

#include <iostream>
#include <string>
#include "Widget.h"
#include "Factory.h"

using namespace std;

int main() {
    // Ler entrada
    string name;
    int value;
    cin >> name >> value;
    
    // TODO: Crie o primeiro widget passando name como um lvalue
    // Armazene o name em uma variável local e passe-o para make_object
    
    
    // TODO: Chame display() no primeiro widget
    
    
    // TODO: Crie o segundo widget passando uma string temporária como um rvalue
    // Passe (name + "_temp") diretamente para make_object
    
    
    // TODO: Chame display() no segundo widget
    
    
    return 0;
}