Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

A referência de encaminhamento `F&&`

Quando `F` é deduzido, `F&&` pode ligar-se a um lvalue ou a um rvalue. `f()` trata o objeto invocável como lvalue; `std::forward<F>(f)` encaminha-o como lvalue ou rvalue, consoante o argumento.

Versão: ISO C++23; implementation support may vary

Sintaxe

#include <utility>

template<class F>
void call(F&& f) {
    std::forward<F>(f)();
}

Em template<class F> void call(F&& f), f é uma referência de encaminhamento: && aplica-se diretamente ao parâmetro de tipo F, sem acrescentar const nem volatile, e F é deduzido na chamada. Para um lvalue de tipo T, deduz-se F = T& e o colapso de referências dá a f o tipo T&. Para um rvalue de tipo T, deduz-se F = T, pelo que f tem o tipo T&&. Os qualificadores do tipo do argumento, como const, mantêm-se.

A presença de && não basta. const F&&, um tipo concreto como Callable&& e F&& quando F já está fixado por uma especialização do modelo de classe não são referências de encaminhamento.

Em f(), a expressão f é um lvalue, mesmo que o tipo declarado do parâmetro seja Callable&&. std::forward<F>(f), de <utility>, usa o F deduzido: para objetos, produz um lvalue para um argumento lvalue e um xvalue (uma espécie de rvalue) para um argumento rvalue. Isto pode alterar a sobrecarga escolhida: operator()() & ou operator()() &&.

std::forward, por si só, não copia nem move o objeto, nem prolonga o seu tempo de vida. Um objeto temporário ligado a um parâmetro de referência dura até ao fim da expressão completa que contém a chamada. Se se guardar uma referência a esse temporário, esta fica pendente após esse ponto.

Exemplos

#include <iostream>
#include <utility>

struct Callable {
    const char* operator()() & { return "lvalue"; }
    const char* operator()() && { return "rvalue"; }
};

template<class F>
void compare(F&& f) {
    const char* direct = f();
    const char* forwarded = std::forward<F>(f)();
    std::cout << direct << ' ' << forwarded << '\n';
}

int main() {
    Callable callable;
    compare(callable);
    compare(Callable{});
}

Resultado

lvalue lvalue
lvalue rvalue

Cada linha mostra primeiro o resultado de `f()` e depois o de `std::forward<F>(f)()`. Para `callable`, ambas as chamadas escolhem `&`; para `Callable{}`, a primeira escolhe `&` e a segunda `&&`. O objeto só é invocado duas vezes para comparar as sobrecargas.

Lições relacionadas

  • C++ · Lição 24 · Avançado · Versão: 3

Fontes