sirve - ¿El valor de retorno de C++ creado antes o después de la destrucción automática de var?

tipos de parametros en c++

Question

En C ++, ¿se garantiza la creación de un valor de retorno antes de que se destruyan las variables automáticas en la función? Aviso cesta :: obtener:

class Basket
{
public:
  // Gift is a struct containing safely copyable things like int or string
  Gift gift;
  // Used to protect access and changes to gift
  Mutex mutex;

  // Copy gift into present, while locked to be thread safe
  void put (const Gift & gift)
  {
    Lock lock(mutex);   // Constructor locks, destructor unlocks mutex
    this->gift = gift;  // Gift assignment operator
  }

  // Return a memberwise-copy of gift, tries to be thread safe (but is it?)
  Gift get ()
  {
    Lock lock(mutex);  // Constructor locks, destructor unlocks mutex
    return gift;       // Gift copy constructor
  }
};

Necesito Basket :: get para realizar su constructor Copia de regalo (del objeto temporal devuelto) antes de la destrucción del objeto de bloqueo. De lo contrario, el objeto de regalo que se está devolviendo puede corromperse por una llamada simultánea a poner.

Mis pruebas muestran que la copia de regalo se creó antes de la destrucción del bloqueo, sin embargo, ¿está garantizado? Si no, necesitaré crear un segundo temporal dentro de la función, como por ejemplo:

  Gift get ()
  {
    Gift result;
    {
      Lock lock(mutex);
      result = gift;
    }
    return result;
  }

Answer 1

Esta garantizado El valor de retorno se copia (si es necesario) antes de que se produzca la destrucción. Aquí hay una pregunta / respuesta similar que da una buena descripción de la secuencia.

Alcance y valores de retorno en C ++

Answer 2

Sí, la variable automática permanecerá dentro del alcance hasta que finalice la devolución. Esto es especialmente cierto si está utilizando un compilador que optimiza el return , por ejemplo:

Gift get() 
{ 
    Lock lock(mutex);
    return gift;
} 

Gift g = basket.get();

Lo que sería equivalente a esta secuencia:

Gift g;
Lock lock(mutex);
g = Gift(gift);
~lock();

Puede ser optimizado para actuar más como esto:

void get(Gift &ret) 
{ 
    Lock lock(mutex);
    ret = gift;
} 

Gift g;
basket.get(g);

Lo que sería equivalente a esta secuencia:

Gift g;
Lock lock(mutex);
g = gift;
~lock();

En otras palabras, un temporal puede ser eliminado durante la return .