Pourquoi ref en C++ 0x ne se comporte-t-il pas comme prévu?

Question

Je suis vraiment désolé pour mes erreurs de formulation précédentes. Donc, je reformulé cette question comme suit:

Le code C++ 0x simple ci-dessous devrait être pas valide:

#include <functional> 

template<class T_> 
void f(T_ obj) 
{ 
    Obj++; // OK that is as expected. 
    static_cast<int&>(obj) = 2; // Though ugly, this is still OK. 

    obj = 2; // However, this line will generate a compiler error 
} 

int main() 
{ 
    int i = 1; 
    f(std::tr1::ref(i)); 
} 

Qui peut me dire la sémantique exacte de ref?

Answer 1

La cause de l'erreur est qu'il n'y a pas d'opérateur d'affectation approprié à appliquer. Le seul candidat est le suivant:

reference_wrapper& operator=(const reference_wrapper<T>& x); 

A reference_wrapper agit comme une référence à l'aide des opérateurs de conversion implicite:

operator T&() const; 

Cependant, une conversion implicite ne se produira pas sur le côté gauche de l'opérateur d'affectation .

Si vous attendez ce modèle pour soutenir reference_wrapper, peut-être vous pouvez travailler autour de manière à ceci:

#include <functional> 
#include <iostream> 

template <class T> 
T& get(T& value) 
{ 
    return value; 
} 

template <class T> 
T& get(std::reference_wrapper<T>& w) 
{ 
    return w.get(); 
} 


template<class T_> 
void f(T_ obj) 
{ 
    //obj = 2; 
    get(obj) = 2; 
} 

int main() 
{ 
    int i = 1; 
    f(std::ref(i)); 
    std::cout << i << '\n'; 
    f(3.14); //at the same time, we want this also to work 
} 

Quant à savoir pourquoi reference_wrapper ne dispose pas d'un opérateur d'affectation pour le type stocké, pas sûr. La version de Boost n'en a pas non plus, et ils disent simplement que cette classe "permet généralement aux modèles de fonction de fonctionner sur des références non modifiées". Je suppose que ce n'est pas l'un de ces cas.