C++ Smart Pointer

The following is the finalized code for a simple C++ smart pointer as demonstrated by my youtube video: 


here


Usage:
void main(){
     ...
    Pointer<ObjectType> pointer(new ObjectType);
    ...
}

1. /*
2.  * Pointer.h
3.  *
4.  *  Created on: Mar 16, 2012
5.  *      Author: ukaku
6.  */
7. 
   
8. #ifndef POINTER_H_
9. #define POINTER_H_
10. 
    
11. #include <iostream>
12. using namespace std;
13. 
    
14. /**
15.  * Reference represents a counter that will be incremented or decremented as
16.  * the number of references to a pecticular pointer is made;
17.  *
18.  * where data means: a symbol used to point to, or associate to another object
19.  */
20. class ReferenceCounter{
21. private:
22.     int counter;
23. public:
24.     ReferenceCounter(){
25.         counter=0;  //initially set to zero
26.     }
27.     void increase(){
28.         counter++;  //increase it
29.     }
30.     int decrease(){
31.         --counter;  //decrease it
32.         if(counter<0){
33.             cout << "ReferenceCouner is < 0"<<endl;
34.         }
35.         return counter; //return its current value
36.     }
37.     int getCount(){
38.         return counter; //simply return the current value
39.     }
40. };
41. 
    
42. 
    
43. template<class T>
44. /**
45.  * Behaves as a smart pointer
46.  */
47. class Pointer {
48.     T* data;
49.     ReferenceCounter* dataReferenceCounter;
50. public:
51.     Pointer() : data(NULL), dataReferenceCounter(NULL){
52.         //set everything to null but allocate a new reference counter
53.         dataReferenceCounter = new ReferenceCounter();
54.         dataReferenceCounter->increase();
55.     }
56.     Pointer(T* xReference) : data(xReference), dataReferenceCounter(NULL){
57.         dataReferenceCounter = new ReferenceCounter();
58.         dataReferenceCounter->increase();
59.     }
60. 
    
61. 
    
62.     Pointer(const Pointer<T> &copy) : data(copy.data), dataReferenceCounter(copy.dataReferenceCounter){
63.         dataReferenceCounter->increase();
64.     }
65.     /**
66.      * Assignment operator
67.      */
68.     Pointer<T>& operator=(const Pointer<T> &other) {
69.         //prevent self assignment
70.         if(this != &other){
71.             //decrease this current instances counter because we are about to override it
72.             if(dataReferenceCounter->decrease()==0){
73.                 delete data;
74.                 delete dataReferenceCounter;
75.             }
76.             data = other.data;
77.             dataReferenceCounter   = other.dataReferenceCounter;
78.             dataReferenceCounter->increase();
79.         }
80.         return *this;
81.     }
82. 
    
83.     virtual ~Pointer(){
84.         //!Only delete the data if and only if no other smart pointer
85.         //!has a data this to data
86.         if(dataReferenceCounter->decrease() == 0){
87.             delete data;
88.             delete dataReferenceCounter;
89.         }
90.     }
91. 
    
92.     T& operator*(){
93.         return *data;
94.     }
95.     T* operator->(){
96.         return data;
97.     }
99. };
101. #endif /* POINTER_H_ */