c++ smart pointer class example

Implementing Reference Semantics

In general, STL container classes provide value semantics and not reference semantics. Thus, they create internal copies of the elements they contain and return copies of those elements. To summarize, if you want reference semantics in STL containers (whether because copying elements is expensive or because identical elements will be shared by different collections), you should use a smart pointer class that avoids possible errors. Here is one possible solution to the problem. It uses an auxiliary smart pointer class that enables reference counting for the objects to which the pointers refer:

#ifndef COUNTED_PTR_HPP #define COUNTED_PTR_HPP /*class for counted reference semantics *-deletes the object to which it refers when the last CountedPtr * that refers to it is destroyed */ template <class T> class CountedPtr { private: T* ptr; // pointer to the value long* count; // shared number of owners public: //initialize pointer with existing pointer //-requires that the pointer p is a return value of new explicit CountedPtr (T* p=0) : ptr(p), count(new long(1)) { } //copy pointer (one more owner) CountedPtr (const CountedPtr<T>& p) throw() : ptr(p.ptr), count(p.count) { ++*count; } //destructor (delete value if this was the last owner) ~CountedPtr () throw() { dispose(); } //assignment (unshare old and share new value) CountedPtr<T>& operator= (const CountedPtr<T>& p) throw() { if (this != &p) { dispose(); ptr = p.ptr; count = p.count; ++*count; } return *this; } //access the value to which the pointer refers T& operator*() const throw() { return *ptr; } T* operator->() const throw() { return ptr; } private: void dispose() { if (--*count == 0) { delete count; delete ptr; } } }; #endif /*COUNTED_PTR_HPP*/

This class resembles the standard auto_ptr class. It expects that the values with which the smart pointers are initialized are return values of operator new. However, unlike auto_ptr, it allows you to copy these smart pointers while retaining the validity of the original and the copy. Only if the last smart pointer to the object gets destroyed does the value to which it refers get deleted.

You could improve the class to allow automatic type conversions or the ability to transfer the ownership away from the smart pointers to the caller.

The following program demonstrates how to use this class:

#include <iostream> #include <list> #include <deque> #include <algorithm> #include "countptr.hpp" using namespace std; void printCountedPtr (CountedPtr<int> elem) { cout << *elem << ' '; } int main() { //array of integers (to share in different containers) static int values[] ={3, 5, 9, 1,6,4}; //two different collections typedef CountedPtr<int> IntPtr; deque<IntPtr> coll1; list<IntPtr> coll2; /*insert shared objects into the collections *-same order in coll1 *-reverse order in coll2 */ for (int i=0; i<sizeof(values)/sizeof(values[0] ); ++i) { IntPtr ptr(new int(values[i])); coll1.push_back(ptr); coll2.push_front(ptr); } //print contents of both collections for_each (coll1.begin(), coll1.end(), printCountedPtr); cout << endl; for_each (coll2.begin(), coll2.end(), printCountedPtr); cout << endl << endl; /*modify values at different places *-square third value in coll1 *-negate first value in coll1 *-set first value in coll2 to 0 */ *coll1[2] *= *coll1[2]; (**coll1.begin()) *= -1; (**coll2.begin()) = 0; //print contents of both collections again for_each (coll1.begin(), coll1.end(), printCountedPtr); cout << endl; for_each (coll2.begin(), coll2.end(), printCountedPtr); cout << endl; }
The program has the following output:

3 5 9 1 6 4 4 6 1 9 5 3 -3 5 81 1 6 0 0 6 1 81 5 -3

Note that if you call an auxiliary function that saves one element of the collections (an IntPtr) somewhere else, the value to which it refers stays valid even if the collections get destroyed or all of their elements are removed.

-----------------------------------------------------------------
See Also:
-----------------------------------------------------------------

• Complete Tutorial of C++ Template's
• Standard Template Library Tutorial
• Inter Process Communication Tutorial
• Advance Programming in C & C++

-----------------------------------------------------------------

The Art of Learning with Innovation,
eLearning Courses for C and C++ Programming Language - The Most appreciated course !!!

Copyright © ccplusplus.com