, new, , delete. , , , .
template <typename T>
struct Status { T *RealPtr; int Count;
};
template <typename T>
class Point
{ Status <T> *StatPtr;
Public:
Point (T * ptr = 0);
Point(const Point &);
~Point();
Point & operator =(const Point &);
T * operator->() const;
T & operator*() const;
void get_count() {cout<<StatPtr->Count<<endl;}
};
template<typename T>
Point<T>::Point(T * ptr)
{ if(!ptr)
StatPtr = NULL;
else
{ StatPtr = new Status <T>; StatPtr->RealPtr=ptr; StatPtr->Count = 1;
}
}
template <typename T>
Point<T>::Point(const Point & p): StatPtr(p.StatPtr)
{ if(StatPtr) StatPtr->Count++;
}
template <typename T>
Point<T>::~Point()
{ if(StatPtr)
{ StatPtr->Count--;
if(StatPtr->Count <= 0)
{delete StatPtr->RealPtr; delete StatPtr;
}
}
}
template <typename T>
T * Point <T>::operator->() const
{ if(StatPtr)
return StatPtr->RealPtr;
else return NULL;
}
template <typename T>
T & Point<T>::operator *() const
{ if(StatPtr) return *StatPtr->RealPtr;
else throw "Opps";
}
template <typename T>
Point<T> & Point<T>::operator =(const Point & p)
{ if(StatPtr)
{StatPtr->Count--;
if(StatPtr->Count <= 0)
{delete StatPtr->RealPtr; delete StatPtr;
}
}
StatPtr = p.StatPtr;
if(StatPtr) StatPtr->Count++; return * this;
}
struct Str
{ int a;
char c;
};
int main()
{ Point<Str> pt1(new Str); // Point,
// pt1,
// Str,
//
Point<Str> pt2=pt1,pt3; // pt2 ,
// pt3
pt3=pt1; // pt3 pt1
(*pt1).a=12; // operator*() this pt1
(*pt1).c='b';
int X=pt1->a; // operator->() this- pt1
char C=pt1->c;
return 0:
}
47. ++.
, − (public), - (private) , . . , .
C++ get_val() put_val() .
|
|
|
_declspec property.
.
class cls
{ int m;
public:
_declspec(property(get=get_val, put=put_val)) int V;
int get_val()
{ return m; }
void put_val(int v)
{ m = v; }
};
:
cls obj;
obj.V = 50; // put_val()
int k = obj.V; // get_val()
:
.
.
, , .
: 5 7 10 . , , :
- ( 5; 10 ; 5; 7; 10 ; 7
, , . , , , , 5 10 , 7 .
____________________
template <class T1>
class A
{
T1 x;
public:
void set(T1 X){x=X;}
T1 get(){return x;}
void Show(){cout<<x<<endl;}
};
template <class T2>
class Tran
{
T2 *that; // A
T2 *prev; //
public:
Tran(){prev = NULL; that = new T2;}
Tran(const Tran &obj):that(new T2(*(obj.that))),prev(NULL){}//constr copy for A
~Tran() {delete prev; delete that;}
Tran &operator = (const Tran & obj);
void Show();
void Begin_Tran(); //
void Commit(); //
void Del_Tran(); //
T2 *operator->();
};
template <class T2>
Tran <T2> & Tran <T2>::operator = (const Tran & obj)
{
if(this!=&obj) { delete that; that = new T2(*(obj.that)); } //prev ,
return *this; //
}
