moniteur avec surcharge d'opérateur C++

Question

Je voudrais écrire une classe wrapper avec tous les opérateurs surchargés de telle sorte que je puisse détecter quand nous écrivons/lisons ou modifions son contenu. Par exemple:

probe<int> x; 
x = 5;  // write 
if(x) { // read 
    x += 7; // modify 
} 

Quelqu'un l'a déjà fait? Si non, quels opérateurs dois-je surcharger pour être sûr de ne rien manquer?

Answer 1

Vous ne pouvez pas, je pense. opérateur?: n'est pas surchargeable. En outre, si T::T(int) est défini, T foo = 4 est légal mais T foo = probe<int>(4) ne l'est pas. Il y a au plus une conversion définie par l'utilisateur.

En outre, parce que la sonde n'est pas un POD, le comportement de votre programme peut changer.

Answer 2

Utilisez ceci comme une idée commune. Il ya beaucoup d'opérateurs comme & = | = [] qui ne sont peut-être pas principal dans votre cas.

template < typename T > 
struct monitor 
{ 
    monitor(const T& data): 
     data_(data) 
    { 
     id_ = get_next_monitor_id(); 
    } 

    monitor(const monitor& m) 
    { 
     id_ = get_next_monitor_id(); 

     m.notify_read(); 
     notify_write(); 

     data_ = m.data_; 
    } 

    operator T() 
    { 
     notify_read(); 
     return data_;  
    } 

    monitor& operator = (const monitor& m) 
    { 
     m.notify_read(); 
     notify_write(); 

     data_ = m.data_; 
     return *this; 
    } 

    monitor& operator += (const monitor& m) 
    { 
     m.notify_read(); 
     notify_write(); 

     data_ += m.data_; 
     return *this; 
    } 
/* 
    operator *= 
    operator /= 
    operator ++(); 
    operator ++ (int); 
    operator --(); 
    operator -- (int); 
*/ 
private: 
    int id_; 
    T data_; 

    void notify_read() 
    { 
     std::cout << "object " << id_ << " was read" << std::endl; 
    } 

    void notify_write() 
    { 
     std::cout << "object " << id_ << " was written" << std::endl; 
    } 
};