Handle Classes: The Smart Pointer

9,208 Expert Mod 8TB

Handle Classes

Handle classes, also called Envelope or Cheshire Cat classes, are part of the Bridge design pattern. The objective of the Bridge pattern is to separate the abstraction from the implementation so the two can vary independently.

Handle classes usually contain a pointer to the object implementation. The Handle object is used rather than the implemented object. This leaves the implemented object free to change without affecting the Handle object. This is exactly what happens with pointers. The object changes but the address in the pointer does not.

One of the problems with passing pointers is that you never know if it's safe to delete the pointer. If the pointer is a stack pointer and you delete, you crash. If the pointer is to a heap object and you delete, the object pointed at is deleted and this is just fine unless there is another pointer somewhere in the program that still points to the object you just deleted. If there is and you use that pointer, you crash. If you play it safe and never delete you die a death by a thousand memory leaks.

Objects of Handle classes are used like pointers even though they are objects. This is accomplished by overloading the dereference operator (*) and the indirection operator (->). Because these are objects, they can contain data beyond the pointer to the implementation. Like maybe, a count of how may other handles also point to the same object.

An internal count of the number of handles containing a pointer to the same object is called a reference count. A handle with an internal reference count is called a reference counted handle.

The rule on reference counting is that when you are to make a function call that requires a pointer, you increment the count for the number of copies of that pointer. When then function you call is about to return, it decrements the count. If the count is now zero, the function has the last copy of the pointer and it is now safe to delete the object pointed at by the pointer.

Here is an example of a handle:

Expand|Select|Wrap|Line Numbers

 
#include <iostream>

using namespace std;
 
//Handle classes or "Cheshire Cat" classes

//separate interface from implementation

//by using an abstract type.
 
//The implementation

class MyClass

{
 
    private:

        int adata;

        int bdata;

    public:

        MyClass(int a, int b) : adata(a), bdata(b) { }

        void Methoda() {cout << "Methoda() " << adata << endl;}    

        void Methodb() {cout << "Methodb() " << bdata << endl;}

};
 
//The interface

class HandleToMyClass

{

    private:

        MyClass* imp;
 
    public:
 
        HandleToMyClass(int x, int y) : imp(new MyClass(x,y)) {  }
 
        MyClass* operator->() {return imp;}
 
};
 
int main()

{    

    /////////////////////////////////////////////////////////////////////////

    //The Handle class manages its own instnace of the Hidden class

    //

    HandleToMyClass hobj(10,20);
 
    hobj->Methoda();    //Use hobj instead of passing copies of MyClass around

    hobj->Methodb();
 
    ////////////////////////////////////////////////////////////////////////
 
    return 0;

}

You can easily see that hobj is an object but it is used in main() as if it were a pointer.

Reference Counted Handles

A reference count keeps track of the number of other handle objects pointing at the same implementation object. This is done by increasing the count in the constructor and decreasing the count in the destructor. When the count goes to zero inside the handle destructor, then it is safe to delete the implementation object. The count itself is also on the heap so it can travel from handle to handle.

In the example below you can see how the count is managed. Note in the handle assignment operator how the count of the LVAL object is decreased and the count of the RVAL object is increased.

Also added to this example is the use of a create function to create the handle. You want to avoid creating an object and then creating a handle and then putting the object pointer inside the handle. The reason to avoid this is: It's not safe. You, at some point, will omit one of the steps or decide to just use the implementation object without bothering about the handle. The entire security net provided by handle fails at this point.

Expand|Select|Wrap|Line Numbers

  
#include <iostream>

using namespace std;
 
//A reference counting handle keeps track of the number of existing copies

//of the handle. The object managed by the handle is not destroyed until

//the destructor of the last handle object is called.
 
class MyClass

{
 
    private:

        int adata;

        int bdata;

    public:

        MyClass(int a, int b) : adata(a), bdata(b) { }

        ~MyClass() {cout << "Egad! The MyClass object is gone!" << endl;}

        void seta(int in) {adata = in;}

        void setb(int in) {bdata = in;}
 
        //Inserter

        friend ostream& operator<<(ostream& os, const MyClass& rhs);

};

//MyClass Inserter

ostream& operator<<(ostream& os, const MyClass& rhs)

{

    os << "adata: " << rhs.adata << " bdata: " << rhs.bdata;

    return os;

}
 
class HandleToMyClass

{

    private:

        MyClass* imp;

        int* RefCount;
 
    public:
 
        HandleToMyClass() : imp(0), RefCount(new int(0)) { }
 
        HandleToMyClass(int x, int y) : imp(new MyClass(x,y)),

                                        RefCount(new int(1)) {  }
 
        //Destructor deletes managed object when reference count is zero

        ~HandleToMyClass();
 
        //Copy constructor increments the reference count

        HandleToMyClass(const HandleToMyClass& rhs);
 
        //Assignment operator decrements lhs reference count and

        //increments rhs reference count

        HandleToMyClass& operator=(const HandleToMyClass& rhs);
 
               //Support using the handle object as a pointer

        MyClass* operator->() {return imp;}

                MyClass& operator*() {return *imp;}

};
 
//Destructor deletes managed object when reference count is zero

    HandleToMyClass::~HandleToMyClass()

{

    //RefCount can be zero if this handle was never assigned an object.

    //In this case subtracting can cause a negative value
 
    if (--(*RefCount) <= 0)    //not thread-safe

    {

            delete imp;

            delete RefCount;

            imp = 0;

            RefCount = 0;
 
    }
 
}
 
//Copy constructor increments the reference count

    HandleToMyClass::HandleToMyClass(const HandleToMyClass& rhs)

    : imp(rhs.imp), RefCount(rhs.RefCount)    //not thread-safe

{

    ++(*RefCount);

}
 
//Assignment operator decrements lhs reference count and

//increments rhs reference count

HandleToMyClass& HandleToMyClass::operator=(const HandleToMyClass& rhs)

{

    if (this == &rhs) return *this; //no assignment to self
 
    //Delete our current implementation (LVAL)

    HandleToMyClass::~HandleToMyClass();
 
    //This is our new implementation (RVAL):

    imp = rhs.imp;

    RefCount = rhs.RefCount;    //not thread-safe

    ++(*RefCount);
 
    return *this;

}

//

//Use a create function to create both the MyClass object and its handle

//

HandleToMyClass CreateMyClassHandle(int a, int b)

{

    return HandleToMyClass(10,20);

}
 
void Process(HandleToMyClass in)

{

        //Silly stuff to exercise the handle

    HandleToMyClass x;
 
    x = in;
 
    HandleToMyClass y(x);
 
    y->seta(30);   //Use handle object as a pointer

}
 
int main()

{    

    //Create the MyClass object and the handle

    //

    HandleToMyClass hobj = CreateMyClassHandle(10,20);
 
    cout << *hobj << endl;
 
    Process(hobj);
 
    cout << *hobj << endl;
 
    ////////////////////////////////////////////////////////////////////////
 
    return 0;

}

Reference Counted Handles as a Template

A Handle is a prime candidate for a template since all Handles behave the same and only the type if the implementation object varies.

Shown below is the Handle as a template as you would see it in a header file. It was prepared from the HandleToMyClass used in the previous example.

You should be able to use this Handle template in your own code.

Expand|Select|Wrap|Line Numbers

 
#ifndef  HANDLETEMPLATEH

#define HANDLETEMPLATEH
 
//A reference counting handle keeps track of the number of existing copies

//of the handle. The object managed by the handle is not destroyed until

//the destructor of the last handle object is called.
 
//Converting the handle to a template:

template<class T>

class Handle

{

    private:

        T* imp;

        int* RefCount;
 
    public:
 
        Handle() : imp(0), RefCount(new int(0)) { }
 
        Handle(T* in) : imp(in), RefCount(new int(1)) {  }
 
        //Destructor deletes managed object when reference count is zero

        ~Handle();
 
        //Copy constructor increments the reference count

        Handle(const Handle<T>& rhs);
 
        //Assignment operator decrements lhs reference count and

        //increments rhs reference count

        Handle<T> operator=(const Handle<T>& rhs);
 
        //Support using the handle object as a pointer

        T* operator->() {return imp;}

        T& operator*() {return *imp;}

};
 
//Destructor deletes managed object when reference count is zero

template<class T>

    Handle<T>::~Handle()

{

    //RefCount can be zero if this handle was never assigned an object.

    //In this case subtracting can cause a negative value

    if (--(*RefCount) <= 0)    //not thread-safe    {

                delete imp;

                delete RefCount;

                imp = 0;

                RefCount = 0;
 
    }

}
 
//Copy constructor increments the reference count

template<class T>

    Handle<T>::Handle(const Handle<T>& rhs)

    : imp(rhs.imp), RefCount(rhs.RefCount)    //not thread-safe

{

    ++(*RefCount);

}
 
//Assignment operator decrements lhs reference count and

//increments rhs reference count

template<class T>

Handle<T> Handle<T>::operator=(const Handle<T>& rhs)

{

    if (this == &rhs) return *this; //no assignment to self
 
    //Delete our current implementation (LVAL)

    Handle::~Handle();
 
    //This is our new implementation (RVAL):

    imp = rhs.imp;

    RefCount = rhs.RefCount;    //not thread-safe

    ++(*RefCount);
 
    return *this;

}
 
#endif  //end of #ifndef HANDLEREFCOUNTTEMPLATEH

Using a Reference Counted Handle

This example shows the reference counted handle in use with MyClass from the first example in this article.

Expand|Select|Wrap|Line Numbers

 
void Process(Handle<MyClass> in)

{

        //Silly stuff to exercise the handle

    Handle<MyClass> x;
 
    x = in;
 
    Handle<MyClass> y(x);
 
    y->seta(30);   //Use handle object as a pointer

}
 
int main()

{    

    //Create the MyClass object and the handle

    //

    Handle<MyClass> hobj = CreateMyClassHandle(10,20);
 
    cout << *hobj << endl;
 
    Process(hobj);
 
    cout << *hobj << endl;
 
    //

    //Unused Handle

    //

    Handle<MyClass> unused;
 
    ////////////////////////////////////////////////////////////////////////
 
    return 0;

}

Create Functions Using the Handle Template

You create a handle by using a create function. Let's assume you have a Person class:

Expand|Select|Wrap|Line Numbers

 
class Person

{

   private:

       string name;

       string address;

   public:

        Person(string name, string address);

        etc...

};

You would write a CreatePersonHandle function as follows:

Expand|Select|Wrap|Line Numbers

 
Handle<Person> hp = CreatePersonHandle("John Smith", "123 Fox St  Anytown USA");

where the create function is:

Expand|Select|Wrap|Line Numbers

 
Handle<Person> CreatePersonHandle(string name, string address)

{

     Person* temp = new Person(name, address);

     Handle<Person> rval(temp);

     return rval;

}

Using the Reference Counted Handle with an STL Container

From here on you use the Handle<Person> as a Person*. If you needed a vector<Person> you would now create a vector<Handle<Person> >:

Expand|Select|Wrap|Line Numbers

 
int main()

{

    Handle<Person? h1 = CreatePersonHandle("John Smith", "123 Fox St  Anytown USA");

    Handle<Person? h2 = CreatePersonHandle("Sue Collins", "James Boulevard  ACity USA");
 
    vector<Handle<Person> > database;

    database.push_back(h1);

    database.push_back(h2);
 
    cout << *database[0] << endl;

    cout << *database[1] << endl;
 
}

The advantage here is the vector is a vector of handles. Each handle has only two pointers: One for the implementation object and one for the count. Making a copy just requires making copies of the pointers rather than the implementation object itself. This will make for a much smaller vector and when elements are deleted, only the two pointers are deleted unless that was the last handle at which time the implementation object is also deleted.

Containers tend to move their contents around. When copies are made, the copy constructor of the objects in the container is called. Almost certainly this will take more time than to copy a Handle. Also, containers, like vector, do not readily release memory. They tend to hoard it to avoid more memory allocations if items are added in the future. A Handle just causes the container to hoard the sizeof two pointers.

Using Handles as Overloaded Operators

Often a sort or some other process is required that involves comparing objects. In these cases, if you have a container of handles, you will be comparing two handles. This is not what you want. You need to compare the objects pointed at by the handles.

First, you do not add operator functions to the Handle template.

Instead, you write a compare function that has Handle arguments and returns the correct bool value. Using the Person class, above, as an example you could:

Expand|Select|Wrap|Line Numbers

 
bool operator<(Handle<Person> left, Handle<Person> right)

{

     if (*left < *right) return true;      //calls Person::operator<

     return false;

}

If the Person class does not have an operator<, then you would use other Person functions to accomplish the comparison:

Expand|Select|Wrap|Line Numbers

 
bool operator<(Handle<Person> left, Handle<Person> right)

{

     if (left->GetName() < right->GetName()) return true;    

     return false;

}

Copyright 2007 Buchmiller Technical Associates North Bend WA USA

Revision History:
Feb 6, 2008: Corrected reference count error in Handle destructor.

May 23 '07 #1

Subscribe Post Reply

35438

Peterwkc

Nice article.

By the way, why u create function create handle rather than inside the constructor.

Another problem is

Expand|Select|Wrap|Line Numbers

 
template<class T>

Handle<T> Handle<T>::operator=(const Handle<T>& rhs)

{

    if (this == &rhs) return *this; //no assignment to self
 
    //Delete our current implementation (LVAL)

    Handle::~Handle();
 
    //This is our new implementation (RVAL):

    imp = rhs.imp;

    RefCount = rhs.RefCount;    //not thread-safe

    ++(*RefCount);
 
    return *this;

}

Why inside assignment operator, why we need to always delete first before assign ?

a = b;

Do we delete a or b ?

Sorry for my stupidity.

Thanks for your help.

Mar 2 '08 #2

weaknessforcats

9,208

Expert Mod 8TB

I use a create function to create, initialize and return a handle to your object. I did this to be sure the Handle was created on the heap.

As to deleting before assigning, think about it. If you are going to replace the current contents of an object with new contents, then you need to delete the current contents to avoid a memory leak. In your example of a = b, it is the contents of a that need to be deleted. Deleting the contents of b would delete the data you want to assign to a.

Mar 4 '08 #3

Similar topics

STL and Handle body pattern

by: Tony Johansson | last post by:

Hello!! Assume I have a handle body pattern with classes called Handle and Body. In the Body class I store one int value for example 7 or some other integer value. In the Handle class I have...

C / C++

ODBC handle classes

by: Indiana Epilepsy and Child Neurology | last post by:

Before asking this questions I've spent literally _years_ reading (Meyer, Stroustrup, Holub), googling, asking more general design questions, and just plain thinking about it. I am truly unable to...

C / C++

Best way to handle ownership

by: Howard | last post by:

Hi, I recently had a problem where I decided to store objects in a vector. (Previously, I had always stored pointers in vectors). Well, naturally, when storing an object in a vector, using...

C / C++

Sorting a vector of classes

by: caxmester | last post by:

Ok this shouldn't be nearly this hard, but i've checked EVERYWHERE from msdn to scouring google & I can't figure it out. I basically have a vector of pointers to "aaWord" objects, each of which...

C / C++

C++ Source Code Documentation for large project

by: Axter | last post by:

I normally use a program call Doxygen to document my source code.(http://www.stack.nl/~dimitri/doxygen) This method works great for small and medium size projects, and you can get good...

C / C++

function pointers and wrapper classes

by: mancomb | last post by:

Hi, I'm curious to the syntax of calling member functions through pointers of classes returned through the -operator. For example (excuse the crude incomplete code); Here are the classes: ...

C / C++

A smart pointer and type forwarding

by: Ney André de Mello Zunino | last post by:

Hello. I have written a simple reference-counting smart pointer class template called RefCountPtr<T>. It works in conjunction with another class, ReferenceCountable, which is responsible for the...

C / C++

Handle?

by: Shraddha | last post by:

What is exactly a handle to an object????Is it same as reference....

C / C++

Type "assurance" of derived classes

by: Oliver Graeser | last post by:

Hi All, I'm coming from Java to C++ and this is one of the very last problems I have so far... In Java, if I have, say, a class SISNode that extends NetworkNode, I can have a function that...

C / C++

Easy Steps to Fix "Canon Printer Won't Connect to WiFi Network"

by: taylorcarr | last post by:

A Canon printer is a smart device known for being advanced, efficient, and reliable. It is designed for home, office, and hybrid workspace use and can also be used for a variety of purposes. However,...

General

Merging data from multiple Excel files

by: ryjfgjl | last post by:

In our work, we often receive Excel tables with data in the same format. If we want to analyze these data, it can be difficult to analyze them because the data is spread across multiple Excel files...

Data Management

Migrating Website to Cloud - Emmanuel Katto

by: emmanuelkatto | last post by:

Hi All, I am Emmanuel katto from Uganda. I want to ask what challenges you've faced while migrating a website to cloud. Please let me know. Thanks! Emmanuel

General

Looking to do Android software development, any suggestions? Is flutter better?

by: nemocccc | last post by:

hello, everyone, I want to develop a software for my android phone for daily needs, any suggestions?

General

Is that possible of reading the .csv file in column wise and the column have different lengths ?

by: Sonnysonu | last post by:

This is the data of csv file 1 2 3 1 2 3 1 2 3 1 2 3 2 3 2 3 3 the lengths should be different i have to store the data by column-wise with in the specific length. suppose the i have to...

C / C++

What is ONU?

by: marktang | last post by:

ONU (Optical Network Unit) is one of the key components for providing high-speed Internet services. Its primary function is to act as an endpoint device located at the user's premises. However,...

General

Changing the language in Windows 10

by: Hystou | last post by:

Most computers default to English, but sometimes we require a different language, especially when relocating. Forgot to request a specific language before your computer shipped? No problem! You can...

Windows Server

Problem With Comparison Operator <=> in G++

by: Oralloy | last post by:

Hello folks, I am unable to find appropriate documentation on the type promotion of bit-fields when using the generalised comparison operator "<=>". The problem is that using the GNU compilers,...

C / C++

Maximizing Business Potential: The Nexus of Website Design and Digital Marketing

by: jinu1996 | last post by:

In today's digital age, having a compelling online presence is paramount for businesses aiming to thrive in a competitive landscape. At the heart of this digital strategy lies an intricately woven...

Online Marketing