Smart Pointer Article Index for
Smart 		Website Links For
Smart 		 

Information About

Smart Pointer
  CATEGORIES ABOUT SMART POINTER
   
data types
   
APPAREL
BABY
BEAUTY
BOOKS
CAR TOYS
CELL PHONES
DVD'S
ELECTRONICS
GOURMET FOOD
GROCERIES
HEALTH & PERSONAL
HOME & GARDEN
JEWELRY
MUSIC
MUSIC INSTRUMENTS
OFFICE PRODUCTS
SOFTWARE
SPORTING GOODS
TOOLS & HARDWARE
TOYS
VIDEO GAMES
SHOPPING HOME
MORE SHOPPING...



The use of pointers is a major source of bugs: the constant allocation, deallocation and referencing that must be performed by a program written using pointers makes it very likely that some , the pointed object is destroyed too.

Several types of smart pointers exist. Some work with Reference Counting , others assigning ownership of the object to a single pointer. If the language supports automatic garbage collection (for instance, Java), then this use of a smart pointer is unnecessary.

In C++ language, smart pointers may be implemented as a template class that mimics, by means of operator overloading, the behaviour of traditional (raw) pointers, (e.g.: dereferencing, assignment) while providing additional memory management algorithms.

Smart pointers can facilitate Intentional Programming by expressing the use of a pointer in the type itself. For example, if a C++ function returns a pointer, there is no way to know whether the caller should delete the memory pointed to when the caller is finished with the information.

  • ambiguous_function(); // What should be done with the result?

    • Traditionally, this has been solved with comments, but this can be error-prone. By returning a C++ Auto_ptr ,

auto_ptr obvious_function1();
the function makes explicit that the caller will take ownership of the result, and further more, that if the caller does nothing, no memory will be leaked. Similarly, if the intention is to return a pointer to an object managed elsewhere, the function could return by reference:
some_type& obvious_function2();


EXAMPLE

Let SmartPointer be a template smart pointer for class X.


void test_smartpointers()
{
//first, we create two objects and we keep raw pointers to them
//since these pointers are not smart, they will not affect the object lifecycle
  • obj_1 = new Object();

  • obj_2 = new Object();


//then we declare two smart pointers and we assign them with the objects
//both obj_1 and obj_2 will have counter==1
SmartPointer p = obj_1;
SmartPointer q = obj_2;

//now we assign p into q, yielding obj_1.counter==2
//obj_2 will be destroyed because its counter reaches 0
q = p;

//we assign q with NULL
//obj_1.counter reaches 1
q = NULL;

//now we create a new object, and we assign its address to the smart pointer
//it will be automatically destroyed before leaving the scope
//obj_1 will be destroyed because its counter reaches 0
p = new Object();

//finally, we create another object which will be only referenced by a raw pointer.
//obj_3 will be lost and there will be a memory leak
  • obj_3 = new Object();

    • }




SEE ALSO



EXTERNAL LINKS