-
Notifications
You must be signed in to change notification settings - Fork 0
/
SafePtr.h
138 lines (123 loc) · 3.64 KB
/
SafePtr.h
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
130
131
132
133
134
135
136
137
138
#ifndef SAFE_PTR_H
#define SAFE_PTR_H
/**
* @file SafePtr.h
* @brief Header file for the SafePtr template class.
*
* This header file defines the `SafePtr` template class, which provides a smart pointer implementation.
* It manages the lifetime of dynamically allocated memory and ensures proper memory management.
*
* @author Your Name (or Company)
* @date 2024-07-09
*/
template<typename T>
/**
* @brief A safe pointer template class.
*
* @tparam T The type of elements stored in the list
*/
class SafePtr {
private:
/**
* @brief Raw pointer to the managed data.
*/
T* ptr;
/**
* @brief Pointer to an unsigned integer that keeps track of the reference count for the managed memory.
*/
unsigned int* refCount;
/**
* @brief Helper function to release the managed memory if the reference count reaches zero.
*/
void release() {
if (refCount) {
(*refCount)--;
if (*refCount == 0) {
delete ptr;
delete refCount;
}
}
}
public:
/**
* @brief Default constructor that initializes both `ptr` and `refCount` to nullptr.
*/
SafePtr() : ptr(nullptr), refCount(nullptr) {}
/**
* @brief Constructor that takes a raw pointer (`p`) as input.
*
* If `p` is not null, it creates a new `refCount` object initialized to 1 and assigns `p` to `ptr`.
*
* @param p The raw pointer to be managed.
*/
explicit SafePtr(T* p) : ptr(p), refCount(p ? new unsigned int(1) : nullptr) {}
/**
* @brief Copy constructor that performs a deep copy of another `SafePtr` object.
*
* It increments the reference count of the shared resource if it exists.
*
* @param other The `SafePtr` object to be copied.
*/
SafePtr(const SafePtr& other) : ptr(other.ptr), refCount(other.refCount) {
if (refCount) {
(*refCount)++;
}
}
/**
* @brief Copy assignment operator that performs a deep copy of another `SafePtr` object.
*
* It first releases the resources managed by the current object (if any)
* and then assigns the `ptr` and `refCount` from the other object.
* It also increments the reference count if the resource is not null.
*
* @param other The `SafePtr` object to be copied from.
* @return A reference to the current `SafePtr` object.
*/
SafePtr& operator=(const SafePtr& other) {
if (this != &other) {
release();
ptr = other.ptr;
refCount = other.refCount;
if (refCount) {
(*refCount)++;
}
}
return *this;
}
/**
* @brief Destructor that calls the `release()` function to ensure proper memory management.
*/
~SafePtr() {
release();
}
/**
* @brief Returns the raw pointer to the managed data.
*
* @return The raw pointer to the managed data (can be nullptr).
*/
T* get() const { return ptr; }
/**
* @brief Dereference operator that returns the value pointed to by the managed data.
*
* It assumes the `ptr` is not null and throws an exception if it is.
*
* @return The value pointed to by the managed data.
*/
T& operator*() const { return *ptr; }
/**
* @brief Arrow operator that returns the address of the value pointed to by the managed data.
*
* It assumes the `ptr` is not null and throws an exception if it is.
*
* @return The address of the value pointed to by the managed data.
*/
T* operator->() const { return ptr; }
/**
* @brief Conversion operator to boolean.
*
* This operator allows using a `SafePtr` object in a boolean context.
* It returns true if `ptr` is not null (meaning it points to valid data) and false otherwise.
*/
operator bool() const { return ptr != nullptr; }
};
#endif // SAFE_PTR_H