Index: src/smart-pointers.h |
diff --git a/src/smart-pointers.h b/src/smart-pointers.h |
index 7c35b2aff27196a65d4e5e3e30326d33c292ad1f..7203c16ba950e1907cda26d07da672022e859a43 100644 |
--- a/src/smart-pointers.h |
+++ b/src/smart-pointers.h |
@@ -36,35 +36,31 @@ template<typename Deallocator, typename T> |
class SmartPointerBase { |
public: |
// Default constructor. Constructs an empty scoped pointer. |
- inline SmartPointerBase() : p_(NULL) {} |
+ SmartPointerBase() : p_(NULL) {} |
// Constructs a scoped pointer from a plain one. |
- explicit inline SmartPointerBase(T* ptr) : p_(ptr) {} |
+ explicit SmartPointerBase(T* ptr) : p_(ptr) {} |
// Copy constructor removes the pointer from the original to avoid double |
// freeing. |
- inline SmartPointerBase(const SmartPointerBase<Deallocator, T>& rhs) |
+ SmartPointerBase(const SmartPointerBase<Deallocator, T>& rhs) |
: p_(rhs.p_) { |
const_cast<SmartPointerBase<Deallocator, T>&>(rhs).p_ = NULL; |
} |
- // When the destructor of the scoped pointer is executed the plain pointer |
- // is deleted using DeleteArray. This implies that you must allocate with |
- // NewArray. |
- inline ~SmartPointerBase() { if (p_) Deallocator::Delete(p_); } |
+ T* operator->() const { return p_; } |
- inline T* operator->() const { return p_; } |
+ T& operator*() const { return *p_; } |
- // You can get the underlying pointer out with the * operator. |
- inline T* operator*() { return p_; } |
+ T* get() const { return p_; } |
// You can use [n] to index as if it was a plain pointer. |
- inline T& operator[](size_t i) { |
+ T& operator[](size_t i) { |
return p_[i]; |
} |
// You can use [n] to index as if it was a plain pointer. |
- const inline T& operator[](size_t i) const { |
+ const T& operator[](size_t i) const { |
return p_[i]; |
} |
@@ -76,13 +72,14 @@ class SmartPointerBase { |
// If you want to take out the plain pointer and don't want it automatically |
// deleted then call Detach(). Afterwards, the smart pointer is empty |
// (NULL). |
- inline T* Detach() { |
+ T* Detach() { |
T* temp = p_; |
p_ = NULL; |
return temp; |
} |
- inline void Reset(T* new_value) { |
+ void Reset(T* new_value) { |
+ ASSERT(p_ == NULL || p_ != new_value); |
if (p_) Deallocator::Delete(p_); |
p_ = new_value; |
} |
@@ -90,7 +87,7 @@ class SmartPointerBase { |
// Assignment requires an empty (NULL) SmartArrayPointer as the receiver. Like |
// the copy constructor it removes the pointer in the original to avoid |
// double freeing. |
- inline SmartPointerBase<Deallocator, T>& operator=( |
+ SmartPointerBase<Deallocator, T>& operator=( |
const SmartPointerBase<Deallocator, T>& rhs) { |
ASSERT(is_empty()); |
T* tmp = rhs.p_; // swap to handle self-assignment |
@@ -99,7 +96,13 @@ class SmartPointerBase { |
return *this; |
} |
- inline bool is_empty() { return p_ == NULL; } |
+ bool is_empty() const { return p_ == NULL; } |
+ |
+ protected: |
+ // When the destructor of the scoped pointer is executed the plain pointer |
+ // is deleted using DeleteArray. This implies that you must allocate with |
+ // NewArray. |
+ ~SmartPointerBase() { if (p_) Deallocator::Delete(p_); } |
private: |
T* p_; |
@@ -119,10 +122,10 @@ struct ArrayDeallocator { |
template<typename T> |
class SmartArrayPointer: public SmartPointerBase<ArrayDeallocator<T>, T> { |
public: |
- inline SmartArrayPointer() { } |
- explicit inline SmartArrayPointer(T* ptr) |
+ SmartArrayPointer() { } |
+ explicit SmartArrayPointer(T* ptr) |
: SmartPointerBase<ArrayDeallocator<T>, T>(ptr) { } |
- inline SmartArrayPointer(const SmartArrayPointer<T>& rhs) |
+ SmartArrayPointer(const SmartArrayPointer<T>& rhs) |
: SmartPointerBase<ArrayDeallocator<T>, T>(rhs) { } |
}; |
@@ -138,10 +141,10 @@ struct ObjectDeallocator { |
template<typename T> |
class SmartPointer: public SmartPointerBase<ObjectDeallocator<T>, T> { |
public: |
- inline SmartPointer() { } |
- explicit inline SmartPointer(T* ptr) |
+ SmartPointer() { } |
+ explicit SmartPointer(T* ptr) |
: SmartPointerBase<ObjectDeallocator<T>, T>(ptr) { } |
- inline SmartPointer(const SmartPointer<T>& rhs) |
+ SmartPointer(const SmartPointer<T>& rhs) |
: SmartPointerBase<ObjectDeallocator<T>, T>(rhs) { } |
}; |