blob: 06f9bbbe2cd06004f7b2a6154ca655c0e74b872b (
plain) (
blame)
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 _SHAREDPOINTER
#define _SHAREDPOINTER
template<class T>
class SharedPointer {
T* value;
unsigned* instances;
void free();
void copyFrom(const SharedPointer& other);
public:
SharedPointer(T* value);
SharedPointer();
~SharedPointer();
SharedPointer(const SharedPointer& other);
SharedPointer& operator=(const SharedPointer& other);
SharedPointer(SharedPointer&& other);
SharedPointer& operator=(SharedPointer&& other);
T& operator*();
const T& operator*() const;
T* operator->();
const T* operator->() const;
unsigned RefCount() const;
};
template <class T>
void SharedPointer<T>::free() {
if (instances == nullptr)
return;
--*instances;
if (*instances == 0) {
delete instances;
delete value;
}
}
template <class T>
void SharedPointer<T>::copyFrom(const SharedPointer& other) {
this->instances = other.instances;
this->value = other.value;
++*instances;
}
template <class T>
SharedPointer<T>::SharedPointer(T* value) : instances(new unsigned), value(value)
{
*instances = 1;
}
template <class T>
SharedPointer<T>::SharedPointer() : instances(), value()
{ }
template <class T>
SharedPointer<T>::~SharedPointer() {
free();
}
template <class T>
SharedPointer<T>::SharedPointer(const SharedPointer& other) {
copyFrom(other);
}
template <class T>
SharedPointer<T>& SharedPointer<T>::operator=(const SharedPointer& other) {
if (this != &other) {
free();
copyFrom(other);
}
return *this;
}
template <class T>
SharedPointer<T>::SharedPointer(SharedPointer&& other) {
instances = other.instances;
value = other.value;
other.instances = nullptr;
other.value = nullptr;
}
template <class T>
SharedPointer<T>& SharedPointer<T>::operator=(SharedPointer&& other) {
if (this != &other) {
free();
instances = other.instances;
value = other.value;
other.instances = nullptr;
other.value = nullptr;
}
return *this;
}
template <class T>
T& SharedPointer<T>::operator*() {
return *value;
}
template <class T>
const T& SharedPointer<T>::operator*() const {
return *value;
}
template <class T>
T* SharedPointer<T>::operator->() {
return value;
}
template <class T>
const T* SharedPointer<T>::operator->() const {
return value;
}
template <class T>
unsigned SharedPointer<T>::RefCount() const {
if (instances == nullptr)
return 0;
return *instances;
}
#endif /* _SHAREDPOINTER */
|
