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

CKTIS / C++

Referência a um lvalue (`R&`)

`R&` é um alias de um objeto existente. Uma atribuição através da referência altera esse objeto. Devolver `R&` permite a quem fez a chamada continuar a aceder ao mesmo objeto sem o copiar.

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

Sintaxe

R& ref = target;
R& get();
const R& read_only = target;

template<class R, class F>
R& run_interval(R& result, F&& namedf, int first, int last);

Uma referência a um lvalue R& é um alias de um objeto existente. Em R& ref = target;, a inicialização associa ref a target sem o copiar. Aqui, & faz parte do declarador e não é o operador de obtenção do endereço. Depois, ref = value; atribui um valor ao objeto, se a atribuição for válida; não altera a associação.

Um int& pode ser associado a uma variável normal de tipo int, mas não a um const int nem ao literal 42. Um const int& não permite alterar o objeto através dessa referência. Pode também ser associado a um objeto temporário; o prolongamento do tempo de vida depende do contexto dessa associação.

No exemplo, R& result é um alias da variável de quem faz a chamada. Para cada i em [first, last), result = namedf(i); escreve nessa mesma variável. A função devolve R&, pelo que a chamada é um lvalue e auto& alias fica associado ao mesmo objeto. Uma devolução por valor não fornece esse alias.

F&& é aqui uma referência de encaminhamento, porque F é um parâmetro de tipo deduzido deste modelo de função, sem qualificadores const ou volatile. A expressão namedf é um lvalue, mesmo que o tipo do parâmetro após a dedução seja uma referência a um rvalue. Assim, namedf(i) invoca o objeto invocável como lvalue. std::forward<F>(namedf) preservaria a distinção entre lvalue e rvalue, mas não necessariamente a categoria de valor exata: a expressão lambda passada como argumento é um prvalue no local da chamada, ao passo que std::forward<F>(namedf) produziria um xvalue. Uma chamada através dessa expressão poderia selecionar outra sobrecarga de operator().

[&] captura por referência a variável local base, usada pelo lambda. A variável global offset está acessível sem captura. Nem devolver uma referência nem capturar por referência prolonga o tempo de vida destas variáveis locais. Não devolvas uma referência para uma variável local cujo tempo de vida termina à saída da função: ler através da referência pendente resultante tem comportamento indefinido.

Exemplos

#include <iostream>

int offset = 1;

template<class R, class F>
R& run_interval(R& result, F&& namedf, int first, int last)
{
    for (int i = first; i < last; ++i) {
        result = namedf(i);
    }
    return result;
}

int main()
{
    int result = 0;
    int base = 39;
    auto& alias = run_interval(result, [&](int i) {
        return base + offset + i;
    }, 0, 3);

    std::cout << result << '\n';
    alias = 43;
    std::cout << result << '\n';
}

Resultado

42
43

Para `i` igual a `0`, `1` e `2`, o ciclo escreve `40`, `41` e `42`. Depois, `alias = 43` altera a mesma variável `result`, pelo que a segunda linha mostra `43`.

Lições relacionadas

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

Fontes