c++ - sizes - Inicialización literal para referencias const.

time variable c++

Question

¿Cómo funciona el siguiente código en C ++? ¿Es lógico?

const int &ref = 9;
const int &another_ref = ref + 6;

¿Por qué C ++ permite la inicialización literal para las referencias const cuando no se permite lo mismo para las referencias no const? P.ej:

const int days_of_week = 7;
int &dof = days_of_week; //error: non const reference to a const object

Esto puede explicarse por el hecho de que se puede usar una referencia no constante para cambiar el valor de la variable a la que se refiere. Por lo tanto, C ++ no permite una referencia no constante a una variable const.

¿Podría ser esta una posible explicación? C ++ no permite:

int &ref = 7;

Porque eso no es lógico, sino:

const int &ref = 7;

Es casi equivalente a:

const int val = 7;

Así que la inicialización literal está permitida para las variables const.

PD: Actualmente estoy estudiando C ++ Primer de Lippman.

Answer 1

Así que puedes escribir código como este:

void f( const string & s ) {
}

f( "foobar" );

Aunque estrictamente hablando, lo que realmente está sucediendo aquí no es el literal que está vinculado a una referencia constante, en lugar de eso, se crea un objeto de cadena temporal:

string( "foobar" );

y esta cadena sin nombre está vinculada a la referencia.

Tenga en cuenta que, en realidad, es bastante inusual crear variables de referencia sin parámetros, ya que el propósito principal de las referencias es servir como parámetros de función y valores de retorno.

Answer 2

Las referencias constantes se pueden inicializar con literales y temporales porque se pueden transformar trivialmente en variables explícitas:

int const& ans = 42;
// tranformed:
int __internal_unique_name = 42;
int const& ans = __internal_unique_name;

O cuando la vida útil no se extiende, como un parámetro de función:

f("foobar");
// transformed:
{
  string __internal_unique_name = "foobar";
  f(__internal_unique_name);
}

(Note el bloque explícito en este caso.)

Si bien es posible hacer algo similar en el caso no constante, eso no está permitido en currenct C ++. Sin embargo, C ++ 0x (el siguiente estándar) tendrá referencias de valor r.

Si no estaba claro, ref + 6 de su código crea un objeto temporal, que puede visualizar como:

int const& ref = int(9);
int const& another_ref = int(ref + 6);

// transformed:
int __A = 9;
int const& ref = __A;
int __B = ref + 6;
int const& another_ref = __B;

Esto puede ayudarlo a comprender / visualizar lo que está sucediendo, pero no debe escribir código real como este. Además, he usado nombres de subrayado dobles para ilustrar que esos nombres son detalles de implementación (utilizados por el compilador) y no deberían ser utilizados por usted. Cualquier nombre que contenga guiones bajos adyacentes está reservado para la implementación de C ++.

Answer 3

Su código se reduce a la regla estándar de C ++ donde la vida útil de un valor temporal está vinculada a la vida útil de la referencia const a la que está asignado. Consulte el artículo de GoTW GotW # 88: Un candidato para la "Constante más importante" para obtener detalles adicionales.

Por ejemplo, la implementación de ScopeGuard , descrita por Alexandrescu y Marginean en el artículo de Dr. Dobbs " Genérico: Cambie la forma en que escribe el Código de excepción segura para siempre " depende de este comportamiento.