c++ - funciones - expresiones rdlc

¿Un error de VS2010? Permitir el enlace de referencia no const a rvalue SIN INCLUIR una advertencia?

Question

string foo() { return "hello"; }
int main()
{
//below should be illegal for binding a non-const (lvalue) reference to a rvalue
string& tem = foo();
//below should be the correct one as only const reference can be bind to rvalue(most important const)
const string& constTem = foo();
}

1. GCC es el mejor para dar un error de compilación : inicialización no válida de referencia no const de tipo std::string& de un temporal de tipo std::string
2. VS2008 no es tan malo como al menos da una advertencia de compilación : advertencia C4239: extensión no estándar utilizada: ''inicialización'': conversión de std::string a std::string & Una referencia no const solo puede estar vinculada a un valor l
3. Aquí viene la problemática: VS2010 (SP1) compila bien SIN ningún error o advertencia, ¿POR QUÉ? Sé que la referencia de valor en VS2010 se puede usar para vincular con rvalue, pero NO estoy usando && ; en cambio, en el código de demostración, ¡solo estaba usando una referencia de valor l no const!

¿Puede alguien ayudarme a explicar el comportamiento de VS2010 aquí? Es un error !? Gracias

Answer 1

El compilador emitirá un error con Desactivar extensiones de idioma activadas, y una advertencia en / W4. Sin embargo, eliminar este código romperá el código de compilación anterior, y Microsoft es muy reacio a hacerlo. Esta es también la razón por la que no repararán su soporte de SFINAE.

Answer 2

Ese es un problema / característica conocida de los compiladores VS. Siempre lo han permitido y no parece haber ningún impulso para eliminar esa extensión .

Answer 3

Hay una variante mucho más desagradable de este problema:

class Foo {
int _val;
public:
Foo(int v) : _val(v) {}
void F() { std::cout << _val << std::endl; }
};
class Bar {
Foo& f;
public:
Bar(Foo& f) : f(f) {}
void F() { f.F(); }
};
int main() {
Bar b(Foo(3));
b.F();
}

Entonces: ¿a qué punto bf durante la llamada a bF() ? El ejemplo anterior, compilado con la configuración de depuración predeterminada de VS2013, se ejecuta sin fallar e imprime 3 , pero sospecho que cualquier ejemplo mucho más complejo dará lugar a la corrupción de la pila. Si no es así y el compilador está haciendo algo ''inteligente'' para que funcione, entonces supongo que lo que realmente está haciendo es esto:

class Foo {
int _val;
public:
Foo(int v) : _val(v) {}
void F() { std::cout << _val << std::endl; }
};
class Bar {
Foo f;
public:
Bar(Foo&& f) : f(f) {}
void F() { f.F(); }
};
int main() {
Bar b(Foo(3));
b.F();
}