Evitar que las plantillas de expresión de enlace a rvalue Referencias de

Question

entiendo que hacer algo como lo siguiente:

auto&& x = Matrix1() + Matrix2() + Matrix3(); 
std::cout << x(2,3) << std::endl; 

causará un error de ejecución en silencio si las operaciones de la matriz utilizan plantillas de expresión (como boost::ublas).

¿Hay alguna manera de diseñar plantillas de expresión para evitar que el compilador compile tal código que puede resultar en el uso de temporarios caducados en el tiempo de ejecución?

(He intentado, sin éxito, para evitar este problema, el intento es here)

Answer 1

¿Hay alguna manera de diseñar las plantillas de expresión para evitar que el compilador de compilación de dicho código que puede resultar en el uso de expirados temporales en tiempo de ejecución?

No. Esto fue realmente reconocido antes de la estandarización final de C++ 11, pero no sé si alguna vez fue presentado al comité. No es que una solución hubiera sido fácil. Supongo que lo más simple sería una bandera en tipos que simplemente error si auto intenta deducirlo, pero incluso eso sería complejo porque decltype también lo puede deducir, así como también la deducción del argumento de la plantilla. Y los tres se definen de la misma manera, pero es probable que no quiera que el último falle.

Simplemente documente su biblioteca de forma adecuada y espere que nadie intente capturarlas de esa manera.

Answer 2

Como lo entiendo, el origen de su problema es que la plantilla de expresiones temporales puede tener referencias/punteros a algunos otros temporales. Y mediante el uso de auto & & solo ampliamos la vida útil de la plantilla de expresión en sí misma, pero no la duración de las temporarias a las que tiene referencias. ¿Es correcto?

Por ejemplo, ¿es this su caso?

#include <iostream> 
#include <deque> 
#include <algorithm> 
#include <utility> 
#include <memory> 
using namespace std; 

deque<bool> pool; 

class ExpressionTemp; 
class Scalar 
{ 
    bool *alive; 

    friend class ExpressionTemp; 

    Scalar(const Scalar&); 
    Scalar &operator=(const Scalar&); 
    Scalar &operator=(Scalar&&); 
public: 
    Scalar() 
    { 
     pool.push_back(true); 
     alive=&pool.back(); 
    } 
    Scalar(Scalar &&rhs) 
     : alive(0) 
    { 
     swap(alive,rhs.alive); 
    } 
    ~Scalar() 
    { 
     if(alive) 
      (*alive)=false; 
    } 
}; 
class ExpressionTemp 
{ 
    bool *operand_alive; 
public: 
    ExpressionTemp(const Scalar &s) 
     : operand_alive(s.alive) 
    { 
    } 
    void do_job() 
    { 
     if(*operand_alive) 
      cout << "captured operand is alive" << endl; 
     else 
      cout << "captured operand is DEAD!" << endl; 
    } 
}; 

ExpressionTemp expression(const Scalar &s) 
{ 
    return {s}; 
} 
int main() 
{ 
    { 
     expression(Scalar()).do_job(); // OK 
    } 
    { 
     Scalar lv; 
     auto &&rvref=expression(lv); 
     rvref.do_job(); // OK, lv is still alive 
    } 
    { 
     auto &&rvref=expression(Scalar()); 
     rvref.do_job(); // referencing to dead temporary 
    } 
    return 0; 
} 

Si sí, entonces una de las posibles soluciones, es hacer tipo especial de provisionales plantilla de expresión que poseen recursos movido de los temporales.

Por ejemplo, consulte el enfoque this (puede definir la macro BUG_CASE, para obtener de nuevo el caso de error).

//#define BUG_CASE 

#include <iostream> 
#include <deque> 
#include <algorithm> 
#include <utility> 
#include <memory> 
using namespace std; 

deque<bool> pool; 

class ExpressionTemp; 
class Scalar 
{ 
    bool *alive; 

    friend class ExpressionTemp; 

    Scalar(const Scalar&); 
    Scalar &operator=(const Scalar&); 
    Scalar &operator=(Scalar&&); 
public: 
    Scalar() 
    { 
     pool.push_back(true); 
     alive=&pool.back(); 
    } 
    Scalar(Scalar &&rhs) 
     : alive(0) 
    { 
     swap(alive,rhs.alive); 
    } 
    ~Scalar() 
    { 
     if(alive) 
      (*alive)=false; 
    } 
}; 
class ExpressionTemp 
{ 
#ifndef BUG_CASE 
    unique_ptr<Scalar> resource; // can be in separate type 
#endif 
    bool *operand_alive; 
public: 
    ExpressionTemp(const Scalar &s) 
     : operand_alive(s.alive) 
    { 
    } 
#ifndef BUG_CASE 
    ExpressionTemp(Scalar &&s) 
     : resource(new Scalar(move(s))), operand_alive(resource->alive) 
    { 
    } 
#endif 
    void do_job() 
    { 
     if(*operand_alive) 
      cout << "captured operand is alive" << endl; 
     else 
      cout << "captured operand is DEAD!" << endl; 
    } 
}; 

template<typename T> 
ExpressionTemp expression(T &&s) 
{ 
    return {forward<T>(s)}; 
} 
int main() 
{ 
    { 
     expression(Scalar()).do_job(); // OK, Scalar is moved to temporary 
    } 
    { 
     Scalar lv; 
     auto &&rvref=expression(lv); 
     rvref.do_job(); // OK, lv is still alive 
    } 
    { 
     auto &&rvref=expression(Scalar()); 
     rvref.do_job(); // OK, Scalar is moved into rvref 
    } 
    return 0; 
} 

Sus sobrecargas operador/función puede devolver different types, en función de T & &/const T & argumentos:

#include <iostream> 
#include <ostream> 
using namespace std; 

int test(int&&) 
{ 
    return 1; 
} 
double test(const int&) 
{ 
    return 2.5; 
}; 

int main() 
{ 
    int t; 
    cout << test(t) << endl; 
    cout << test(0) << endl; 
    return 0; 
} 

lo tanto, cuando la plantilla de la expresión temporal no tienen recursos movido de los temporales - es el tamaño no se verá afectado.