EE 360C Algorithms and Data Structures using C++

In C++, remembering to delete a pointer to an object is required so that you prevent memory leaks in your program. However, it is often the case that one forgets to explicitly call delete, or a pointer is returned from a procedure and it is not clear who then has responsibility for freeing the object associated with the pointer. Some languages support the concept of “garbage collection” of objects, which frees the programmer from having to worry about explicitly deleting an object. When an is no longer referenced by any pointer in the program, an automatic garbage collector will reclaim the storage associated with that object. There are many different methods for garbage collection. The most efficient garbage collectors are integrated with the compiler run-time system. It is difficult to implement completely automatic garbage collection without changing the compiler. However, using templates in C++, we can define a “smart pointer” abstraction, which is a class containing a pointer to an object and a reference count associated with the object. The reference count is incremented for each smart pointer that is made to point at the object. The reference count is decremented when a smart pointer no longer points at an object. When the reference count is zero, the object is destructed. Reference counting works when the number of pointers to an object is relatively small, so that the cost of updating the reference count is not too high. Reference counts do not work when there is a cycle----the count will never reach zero. Using a smart pointer template, a cycle does not usually occur, so that is not a problem in practi;T> RefCnt<T>*_ptr T* _obj int _cnt T
SPtr(const SPtr<T>& p) { _ptr = p._ptr; _ptr->inc(); } ~SPtr() { if (_ptr->dec() == 0) delete _ptr; }
8/5/00
1 of 8
EE 360C
Algorithms and Data Structures using C++
lecture-19.fm
EE 360C
Algorithms and Data Structures using C++
lecture-19.fm
A “Smart” Pointer Implementation
Smart Pointer Template Implementation
template<class T> class SPtr { RefCnt<T>* _ptr; /* hide new/delete to disallow allocating a SPtr<T> from the heap */ static void* operator new(size_t) {} static void operator delete(void*) {} public: SPtr(T* p) { _ptr = new RefCnt<T>(p); _ptr->inc(); }
#include <assert.h> template<class T> class RefCnt { T* _obj; int _cnt; public: RefCnt(T* p) : _obj(p), _cnt(0) {} ~RefCnt() { assert(_cnt == 0); delete _obj; } // dereference operator, returns pointer to object T* operator*() { return _obj; } int inc() { _cnt++; return _cnt; } int dec() { _cnt--; return _cnt; } };
. . .
SPtr<T> RefCnt<T>*_ptr
void operator=(const SPtr<T>& p) { if (this != &p) { if (_ptr->dec() == 0) delete _ptr; _ptr = p._ptr; _ptr->inc(); } } T* operator->() { return *(*_ptr); } };
Multiple SPtr<T> template instances point to a single RefCnt<T> instance, which holds a pointer and a reference count to an instance of a class T (e.g., String). The SPtr<T> template is a handle that is used to access a reference counted object and which updates the reference count. • on construction of a SPtr<T> instance, the count is incremented • on destruction of a SPPtr<T>the count is decremented. • when the last SPtr<T> object is destructed, the RefCnt<T> is deleted, which in turn deletes the object of type T.
String* get_token(istream& s) { String* token= new String; ... // get token from stream return token; }
Example
How/when does the String object get deleted?
String *s = get_token(cin); ... delete s; You have to remember to delete the object, and this may be a problem if you pass the pointer around to other procedures and the “ownership” of the object becomes unclear. You have to remember to delete the object later, and also make sure that you did not put the pointer into a data structure somewhere that could result in a pointer pointing to an object that you delete too soon (caled a “dangling pointer”). StringPtr get_token(istream& s) { String* s = new String; ... return s; // calls StringPtr(String*) constructor with s } { // some scope in which get_token is called StringPtr sp = get_token(cin); ... sp->length(); // calls StringPtr::operator->(), then String::length() } // StringPtr is deleted when scope is exited, and so is the String object 8/5/00 2 of 8