1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
| // classe non copiable
struct NC
{
NC() : ptr_(new T(p1, p2)) {}
void f() { ptr_->do_smthg(v); }
private:
// la ressource de NC, allouée et construite dynamiquement
const std::auto_ptr<T> ptr_;
// mieux:: boost:scope_ptr<T> ptr_;
};
// obj sur le tas, dit "automatique"
NC nc;
nc.f();
NC nc2 = nc; // interdit!!
NC nc3;
nc3 = nc; // interdit aussi
// obj sur le tas ; hyper simplifié
NC * pnc = new NC();
try { ... ; pnc->f(); .... }
catch ...... { ... }
delete pnc;
// obj sur tas bis -> localisé à un bloc
{ ... std::auto_ptr<NC> pnc2( new NC ); .... }
// obj sur le tas ter -> peut voyager entre des portées différentes
boost::shared_ptr<NC> pnc3( new NC );
//-----------------------
// classe copiable
struct C
{
C() : ptr_(new T(p1, p2)) {}
void f() { ptr_->do_smthg(v); }
private:
boost::shared_ptr<T> ptr_;
};
// utilisation tout pareil, sauf que
C c2 = c;
C c3;
c3 = c;
// marchent
//--------------------------
// classe copiable, fait main; version valide pour une et
// une seule ressource ; ici un pointeur
struct CM {
CM() : ptr_(new T(p1, p2 )) {}
~CM() { delete ptr_; } // nécessaire
CM( CM const& rhs ) // nécessaire
: ptr_( new T(rhs.ptr_) )
// ou "ptr_( rhs.ptr_->clone() )" suivant la sémantique de T
{} // toujours pas de corps
CM & operator=(CM const & rhs) // nécessaire également
{ CM tmp(rhs); swap(tmp); return *this; }
void swap( CM & other ) { std::swap(ptr_, other.ptr_); }
void f() { ptr_->do_smthg(v); }
private:
T ptr_;
};
// utilisation comme pour la classe C |
Partager