init

w1146869587

2022-01-24 0408576e9da10015ffa9da0079b8c985113ce4b3

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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
#ifndef __QLObjPtr
#define __QLObjPtr
 
template <class T>
class AFX_EXT_CLASS _NoAddRefReleaseOnCQLObjPtr : public T
{
    private:
        long AddRef();
        long Release();
};
 
/////////////////////////////////////////////
// CQLObjPtr
// 
// ÖÇÄÜÖ¸Õ룬×Ô¶¯AddRefÓëRelease
// _NoAddRefReleaseOnCOIObjPtr
// ÖÇÄÜÖ¸Õë·ÀÖ¹µ÷ÓÃAddRefÓëRelease
// Ptr>Release(); Ó¦¸ÃΪPtr.Release();ÓÉÕâ¸öÀàÀ´±£Ö¤²»»á³öÏÖ
/////////////////////////////////////////////
template <class T>
class AFX_EXT_CLASS CQLObjPtr
{
public:
    typedef T _PtrClass;
    CQLObjPtr()
    {
        p = NULL;
    }
    CQLObjPtr(T* lp)
    {
        if ((p = lp) != NULL)
            p->AddRef();
    }
    CQLObjPtr(const CQLObjPtr<T>& lp)
    {
        if ((p = lp.p) != NULL)
            p->AddRef();
    }
    ~CQLObjPtr()
    {
        if (p)
            p->Release();
    }
    long Release()
    {
        T* pTemp = p;
        if (pTemp)
        {
            p = NULL;
            return pTemp->Release();
        }
 
        return 0;
    }
    operator T*() const
    {
        return (T*)p;
    }
    T& operator*() const
    {
        ATLASSERT(p!=NULL);
        return *p;
    }
    //The assert on operator& usually indicates a bug.  If this is really
    //what is needed, however, take the address of the p member explicitly.
//    T** operator&()
//    {
//        ATLASSERT(p==NULL);
//        return &p;
//    }
    _NoAddRefReleaseOnCQLObjPtr<T>* operator->() const
    {
        ATLASSERT(p!=NULL);
        return (_NoAddRefReleaseOnCQLObjPtr<T>*)p;
    }
    T* operator=(T* lp)
    {
        if (lp != NULL)
            lp->AddRef();
        if (p)
            p->Release();
        p = lp;
        return lp;
    }
    T* operator=(const CQLObjPtr<T>& lp)
    {
        if (lp != NULL)
            lp.p->AddRef();
        if (p)
            p->Release();
        p = lp;
        return lp;
    }
    bool operator!() const
    {
        return (p == NULL);
    }
    bool operator<(T* pT) const
    {
        return p < pT;
    }
    bool operator==(T* pT) const
    {
        return p == pT;
    }
    // Compare two objects for equivalence
    bool IsEqualObject(T* pOther)
    {
        if ( p == pOther )
            return true;
 
        return false;
    }
    void Attach(T* p2)
    {
        if (p)
            p->Release();
        p = p2;
    }
    T* Detach()
    {
        T* pt = p;
        p = NULL;
        return pt;
    }
    T* p;
};
 
#endif // __QLObjPtr