Geekpedia Tutorials Home

Building a C# Chat Client and Server

Building a C# Chat Client and ServerA step by step tutorial teaching you how to create your own chat client and chat server easily in C#, for local networks or the Internet.

in C# Programming Tutorials

Getting Hard Drive Information

Getting Hard Drive InformationA C# tutorial showing you how to make use of WMI to extract information on disk drives, such as model, capacity, sectors and serial number.

in C# Programming Tutorials

UPS Shipping Calculator

UPS Shipping CalculatorThis tutorial will teach you how to calculate the shipping cost based on the weight, height, length and depth of the box, the distance and the UPS service type.

in PHP Programming Tutorials

Create Your Own Rich Text Editor

Create Your Own Rich Text EditorCreating a Rich Text Editor using JavaScript is easier to do than you might think, thanks to the support of modern browsers; this tutorial will walk you through it.

in JavaScript Programming Tutorials
Search
Tutorials
Programming Tutorials
IT Jobs
From CareerBuilder
Geekpedia » C++ Tutorials » Smart Pointers - Part II

Smart Pointers - Part II

In this part we implement a Garbage Collection with C++.

 On Wednesday, June 9th 2004 at 03:22 AM
By Hamed Zaghaghi (View Profile)
*****   (Rated 4.2 with 12 votes)
Contextual Ads
More C++ Resources
Advertisement

Keywords:

-Lifetime:
The period during witch an object exist, is the “Lifetime” of this object.

-Access Path:
“Access Path” to an object is the path that can access to an object.

-Garbage:
If all Access Paths to a Data Object (DO) loses, this Data Object is like “Garbage” in the memory.

-Dangling Reference:
If “Lifetime” of each Data Object (DO) was finished, when there is at least one “Access Path” to it, all Access Paths are “Dangling Reference”.



Example of Garbage:


int *  pi1 =  new int; // first DO
int *  pi2 =  new int; // second DO
pi2 = pi1;  //  now pi1 and pi2 refer to first DO 
                //   and the all access path to the second DO loses;




Example of Dangling Reference:


int  * pi = new int; // first DO
delete pi;
...
//use the pi makes runtime error.



Now we want to solve garbage problem, which named Garbage Collection.

One of the ways that solve this problem is:
1.Delete all data objects that create using new or malloc.
2.When delete a reference to a data object don’t forget assign NULL to the pointer.

But I write a class in C++ that if I and you forgot the two rules above.

In this Class I use below techniques and if you don’t know one of them I suggested that you learn these techniques before reading the code.
-Templates
-Smart Pointers
-Overloading operators
-And other object oriented techniques.



template<typename T>
class CDataPacket
{
private:
    int RefNum;
public:
    T* pData;
    CDataPacket();
    ~CDataPacket();
    void DecRef();
    void IncRef();
};


This class provides a data object that can be reference to a user data object, and count the references to it, and increment and decrement the reference counter.

In this object when the references counter equal to zero, user data object and this object deleted.


template<typename T>
class CPtr
{
private:
    CDataPacket<T> * Refs;
public:
    ~CPtr();
    CPtr();
    T* operator->();
    T & operator*();
    operator T*();
    CPtr<T>& operator = ( T* p);
    CPtr<T>& operator = ( CPtr<T>& p);
};


This class provide an interface for users that can work with this object like the pointers, also this class administrate the assignments, because in assignments references increment and decrement.

Below is the implementation of above classes.


template<typename T>
void CDataPacket<T>::DecRef()
{
    if (RefNum == 0) return;
 
    RefNum--;
    if (RefNum == 0)
        delete this;
}
 
template<typename T>
void CDataPacket<T>::IncRef()
{
    RefNum++;
}
 
template<typename T>
CDataPacket<T>::CDataPacket()
{
    pData = NULL;
    RefNum = 0;
}
 
template<typename T>
CDataPacket<T>::~CDataPacket()
{
    delete pData;
}




template<typename T>
CPtr<T>& CPtr<T>::operator= ( T* p)
{
    if ( Refs)
        Refs->DecRef();
    Refs = new CDataPacket<T>;
    Refs->pData = p;
    Refs->IncRef();
    return *this;
}
 
template<typename T>
CPtr<T>& CPtr<T>::operator= ( CPtr<T>& p)
{
    if ( Refs)
        Refs->DecRef();
    Refs = p.Refs;
    Refs->IncRef();
    return *this;
}
 
template<typename T>
CPtr<T>::~CPtr()
{
    Refs->DecRef();
}
 
template<typename T>
CPtr<T>::CPtr()
{
    Refs = NULL;
}
 
template<typename T>
T* CPtr<T>::operator ->()
{
    return Refs->pData;
}
 
template<typename T>
T& CPtr<T>::operator *()
{
    return *(Refs->pData);
}
 
template<typename T>

CPtr<T>::operator T*()

{

      return Refs->pData;

}




Example of using these classes:

Ex1:


void main()
{
      CPtr<int> pii;
      pii = new int[10];
      pii[0]=0;
      pii[2]=10;
      cout << pii[0] << endl;
      cout << pii[2] << endl;
}



Output:
0
10


Ex2:


class test
{
private:
      int data;

public:
      test(int i){ data = i;};
      ~test(){ cout << " class #"<<data<<" destroyed."<< endl; };
      void DoSomeThing(){ cout << " class #"<<data<<" doing something."<< endl; };
};

void main()
{
      CPtr<test> ts,ts1,ts2;

      ts = new test(0);
      ts1 = new test(1);
      ts2 = new test(2);      

      ts->DoSomeThing();      // output in line 1
      ts1->DoSomeThing();     // output in line 2
      ts2->DoSomeThing();     // output in line 3

      ts = ts1;               // output in line 4
      ts1 = ts2;              

      ts->DoSomeThing();      // output in line 5
      ts1->DoSomeThing();     // output in line 6
      ts2->DoSomeThing();     // output in line 7

      ts1 = ts;

      ts->DoSomeThing();      // output in line 8
      ts1->DoSomeThing();     // output in line 9
      ts2->DoSomeThing();     // output in line 10

      (*ts).DoSomeThing();    // output in line 11
}                             // output in line 12,13


Output:

1: class #0 doing something.
2: class #1 doing something.
3: class #2 doing something.
4: class #0 destroyed.
5: class #1 doing something.
6: class #2 doing something.
7: class #2 doing something.
8: class #1 doing something.
9: class #1 doing something.
10: class #2 doing something.
11: class #1 doing something.
12: class #2 destroyed.
13: class #1 destroyed.

Have a Goooood Day, with more errorless programming.
Digg Digg It!     Del.icio.us Del.icio.us     Reddit Reddit     StumbleUpon StumbleIt     Newsvine Newsvine     Furl Furl     BlinkList BlinkList

Rate Rate this tutorial
Comment Current Comments
by bernard jones on Tuesday, November 2nd 2004 at 02:19 AM

the bets ive seen for a while

by akshay on Monday, July 7th 2008 at 08:30 AM

Smart Pointers - Part II
In this part we implement a Garbage Collection with C .
On Wednesday, June 9th 2004 at 03:22 AM
--------------------------------------------------------------------------------
By Hamed Zaghaghi (View Profile)
--------------------------------------------------------------------------------
(Rated 4.1 with 11 votes)
Contextual Ads
More C Resources
C Tutorials
C Code
C Jobs
Advertisement Keywords:

-Lifetime:
The period during witch an object exist, is the “Lifetime” of this object.

-Access Path:
“Access Path” to an object is the path that can access to an object.

-Garbage:
If all Access Paths to a Data Object (DO) loses, this Data Object is like “Garbage” in the memory.

-Dangling Reference:
If “Lifetime” of each Data Object (DO) was finished, when there is at least one “Access Path” to it, all Access Paths are “Dangling Reference”.



Example of Garbage:




int * pi1 = new int; // first DO
int * pi2 = new int; // second DO
pi2 = pi1; // now pi1 and pi2 refer to first DO
// and the all access path to the second DO loses;




Example of Dangling Reference:




int * pi = new int; // first DO
delete pi;
...
//use the pi makes runtime error.



Now we want to solve garbage problem, which named Garbage Collection.

One of the ways that solve this problem is:
1.Delete all data objects that create using new or malloc.
2.When delete a reference to a data object don’t forget assign NULL to the pointer.

But I write a class in C that if I and you forgot the two rules above.

In this Class I use below techniques and if you don’t know one of them I suggested that you learn these techniques before reading the code.
-Templates
-Smart Pointers
-Overloading operators
-And other object oriented techniques.





template<typename T>
class CDataPacket
{
private:
int RefNum;
public:
T* pData;
CDataPacket();
~CDataPacket();
void DecRef();
void IncRef();
};


This class provides a data object that can be reference to a user data object, and count the references to it, and increment and decrement the reference counter.

In this object when the references counter equal to zero, user data object and this object deleted.




template<typename T>
class CPtr
{
private:
CDataPacket<T> * Refs;
public:
~CPtr();
CPtr();
T* operator->();
T


Comment Comment on this tutorial
Name: Email:
Message:
Comment Related Tutorials
There are no related tutorials.

Comment Related Source Code
There is no related source code.

Jobs C++ Job Search
My skills include:
Enter a City:

Select a State:
Advanced Search >>
Sponsors
Discover Geekpedia
News News
Tutorials Tutorials
Source Code Source Code
Pictures Pictures
Videos Videos
Reviews Reviews
Special Report Special Reports
Bargains Bargains
Resources Resources
Icons Icons
Newsgroups Newsgroups
Knowledge Base Knowledge Base
Books Books
Magazines Magazines
Books Downloads
Jobs Jobs
Forums Forums
Search Search

Other Resources