suma - C++: ¿el valor de retorno es un valor L?

que es una funcion dev c++

Question

Considera este código:

struct foo
{
  int a;
};

foo q() { foo f; f.a =4; return f;}

int main()
{
  foo i;
  i.a = 5;
  q() = i;
}

Ningún compilador se queja de eso, incluso Clang. ¿Por qué q() = ... línea es correcta?

Answer 1

Debido a que las estructuras se pueden asignar a, y su q() devuelve una copia de struct foo para que asigne la estructura devuelta al valor proporcionado.

Esto realmente no hace nada en este caso porque la estructura se sale del alcance y no se hace referencia a ella en primer lugar, por lo que no se puede hacer nada con ella de todos modos (en este código específico).

Esto tiene más sentido (aunque todavía no es una "mejor práctica")

struct foo
{
  int a;
};

foo* q() { foo *f = new malloc(sizeof(foo)); f->a = 4; return f; }

int main()
{
  foo i;
  i.a = 5;

  //sets the contents of the newly created foo
  //to the contents of your i variable
  (*(q())) = i;
}

Answer 2

No, el valor de retorno de una función es un valor l si y solo si es una referencia (C ++ 03). (5.2.2 [expr.call] / 10)

Si el tipo devuelto fuera un tipo básico, esto sería un error de compilación. (5.17 [expr.ass] / 1)

La razón por la que esto funciona es porque se le permite llamar a funciones miembro (incluso funciones miembro no const ) en r-values ​​del tipo de clase y la asignación de foo es una función miembro definida por la implementación: foo& foo::operator=(const foo&) Las restricciones para los operadores en la cláusula 5 solo se aplican a los operadores incorporados , (5 [expr] / 3), si la resolución de sobrecarga selecciona una llamada de función sobrecargada para un operador, entonces se aplican las restricciones para esa llamada de función.

Esta es la razón por la cual a veces se recomienda devolver objetos del tipo clase como objetos const (ej. const foo q(); ), sin embargo esto puede tener un impacto negativo en C ++ 0x donde puede impedir que la semántica de movimiento funcione como debería.

Answer 3

Una aplicación interesante de esto:

void f(const std::string& x);
std::string g() { return "<tag>"; }

...

f(g() += "</tag>");

Aquí, g() += modifica el temporal, que puede ser más rápido que la creación de un temporal adicional con + porque el montón asignado para el valor de retorno de g () puede tener suficiente capacidad libre para acomodar </tag> .

Véalo ejecutarse en ideone.com con GCC / C ++ 11 .

Ahora, ¿qué novato de la informática dijo algo acerca de las optimizaciones y el mal ...? ; -].