Prevenire modelli di espressione vincolanti per rvalue fa riferimento

Question

Capisco che fare qualcosa di simile al seguente:

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

causerà un errore di runtime in silenzio se le operazioni di matrice utilizzano modelli di espressione (ad esempio boost::ublas).

Esiste un modo per progettare modelli di espressioni per impedire al compilatore di compilare tale codice che potrebbe comportare l'utilizzo di provvisori scaduti in fase di runtime?

lì (ho tentato senza successo di risolvere questo problema, il tentativo è here)

Answer 1

è alcun modo di progettare modelli di espressione per evitare che il compilatore di compilazione di tale codice che può comportare l'uso di Temporary scaduti in fase di runtime?

No. Questo è stato effettivamente riconosciuto prima della standardizzazione finale del C++ 11, ma non so se è mai stato portato a conoscenza della commissione. Non che una soluzione sarebbe stata facile. Suppongo che la cosa più semplice sarebbe un flag sui tipi che farebbe semplicemente errore se auto prova a dedurlo, ma anche quello sarebbe complesso perché lo può dedurre anche da decltype, così come deduzione argomento template. E tutti e tre sono definiti nello stesso modo, ma probabilmente non vuoi che fallisca.

Basta documentare la libreria in modo appropriato e sperare che nessuno cerchi di catturarli in quel modo.

Answer 2

Come ho capito, la radice del problema è che il modello di espressione temporaneo può avere riferimenti/puntatori ad altri temporaries. E usando l'auto & & estendiamo solo la vita del modello di espressione temporaneo, ma non la durata dei temporari a cui ha riferimenti. È giusto?

Per esempio, è this il tuo 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; 
} 

In caso affermativo, una delle possibili soluzioni consiste nel creare un tipo speciale di modello di espressione temporaneo che trattiene le risorse spostate dai provvisori.

Ad esempio, controllare l'approccio this (è possibile definire la macro BUG_CASE per ottenere nuovamente il caso di errore).

//#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; 
} 

vostri sovraccarichi operatore/funzione può restituire different types, a seconda T & &/const T & argomenti:

#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; 
} 

Così, quando il vostro modello di espressione temporanea non hanno risorse spostati da provvisori - è le dimensioni non saranno influenzate.