CKTIS / C++
Referencia a lvalue (`R&`)
`R&` es un alias de un objeto existente. Asignar a través de la referencia modifica ese objeto. Devolver `R&` permite que quien llama siga accediendo al mismo objeto sin copiarlo.
Versión: ISO C++23; implementation support may vary
Sintaxis
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);Una referencia a lvalue R& es un alias de un objeto existente. En R& ref = target;, la inicialización vincula ref con target sin copiarlo. Aquí & forma parte del declarador y no es el operador de obtención de dirección. Después, ref = value; asigna al objeto si la asignación es válida; no cambia el objeto al que se refiere ref.
Un int& puede vincularse a una variable ordinaria de tipo int, pero no a un const int ni al literal 42. Un const int& no permite modificar el objeto a través de esa referencia. También puede vincularse a un objeto temporal; que se prolongue su tiempo de vida depende del contexto de vinculación.
En el ejemplo, R& result es un alias de la variable de quien llama. Para cada i en [first, last), result = namedf(i); escribe en esa misma variable. La función devuelve R&, así que la llamada es un lvalue y auto& alias se vincula al mismo objeto. Devolver por valor no proporciona ese alias.
Aquí F&& es una referencia de reenvío porque F es un parámetro de tipo deducido de esta plantilla de función, sin los calificadores const ni volatile. La expresión namedf es un lvalue, aunque el tipo del parámetro tras la deducción sea una referencia a rvalue. Por eso namedf(i) invoca el objeto invocable como lvalue. std::forward<F>(namedf) conservaría la distinción entre lvalue y rvalue, pero no necesariamente la categoría de valor exacta: la expresión lambda pasada como argumento es un prvalue en el punto de llamada, mientras que std::forward<F>(namedf) produciría un xvalue. Una llamada a través de esa expresión podría seleccionar otra sobrecarga de operator().
[&] captura por referencia la variable local base, que usa la lambda. Se puede acceder a la variable global offset sin capturarla. Ni devolver una referencia ni capturar por referencia prolonga el tiempo de vida de estas variables locales. No devuelvas una referencia a una variable local cuyo tiempo de vida termina al salir de la función: leer a través de la referencia colgante resultante provoca un comportamiento indefinido.
Ejemplos
#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` y `2`, el bucle escribe `40`, `41` y `42`. Luego `alias = 43` modifica la misma variable `result`, así que la segunda línea muestra `43`.
Lecciones relacionadas
- C++ · Lección 24 · Avanzado · Versión: 3