A veces nos gusta tomar un parámetro grande por referencia, y también hacer que la referencia sea constante si es posible para anunciar que es un parámetro de entrada. Pero al hacer la referencia constante, el compilador se permite convertir datos si son del tipo incorrecto. Esto significa que no es tan eficiente, pero más preocupante es el hecho de que creo que me estoy refiriendo a los datos originales; tal vez tomaré su dirección, sin darme cuenta de que, en efecto, estoy tomando la dirección de un temporal.

La llamada abar en este código falla. Esto es deseable, porque la referencia no es del tipo correcto. La llamada abar_const también es del tipo incorrecto, pero se compila silenciosamente. Esto no es deseable para mí.

#include<vector>
using namespace std;

int vi;

void foo(int &) { }
void bar(long &) { }
void bar_const(const long &) { }

int main() {
   foo(vi);
   // bar(vi); // compiler error, as expected/desired
   bar_const(vi);
}

¿Cuál es la forma más segura de pasar una referencia ligera de solo lectura? Estoy tentado de crear una nueva plantilla de referencia.

(Obviamente,int ylong son tipos muy pequeños. Pero he quedado atrapado con estructuras más grandes que se pueden convertir entre sí. No quiero que esto suceda en silencio cuando tomo una referencia constante. A veces, marcar los constructores como ayudas explícitas, pero eso no es lo ideal)

Actualizar Imagino un sistema como el siguiente: Imagina tener dos funcionesX byVal(); yX& byRef(); y el siguiente bloque de código:

 X x;
 const_lvalue_ref<X> a = x; // I want this to compile
 const_lvalue_ref<X> b = byVal(); // I want this to fail at compile time
 const_lvalue_ref<X> c = byRef(); // I want this to compile

Este ejemplo se basa en variables locales, pero quiero que también funcione con parámetros. Quiero recibir algún tipo de mensaje de error si accidentalmente paso una referencia temporal o una referencia a una copia cuando creo que voy a pasar algo liviano como un valor de referencia. Esto es solo una cuestión de 'estándar de codificación': si realmente quiero permitir pasar una referencia a una temporal, entonces usaré un sencilloconst X&. (Estoy encontrandoesta pieza en FOREACH @ de Boo para ser bastante útil.)