Hardwired's Thread Safe Double Link List Template

• Download source files - 5.41 Kb

Introduction

As promised in Single Link List article, here is the implementation of Double Link List, in thread safe way. This article is quite similar to the one I've already mentioned.

You might find it useful to your applications.

Using the code

First, add everything that's in the pack to your project:

• LinkedListDouble.h
• LinkedListDouble.cpp
• NamedCriticalSection.h
• NamedCriticalSection.cpp
• SpinLock.h
• SpinLock.cpp
• DebugTrace.h
• DebugTrace.cpp

Second, include this where you need to declare a new list:

#include "LinkedListDouble.h"

// you need this too, or the code for the list will not be generated!!!

#include "LinkedListDouble.cpp"

Once you did all this, declare a new list, like this:

//

// somewhere in your application:

//


CLinkedListDouble<int, sinzeof(int)>   IntegerList;

The template can be used with anything... so, let's complicate the things a bit. Let's say we have this class:

//

// some class

//


class SomeClass
{
    double        DVar;    // a double private data member


public:

    char        szString[ 32 ];    // a string public data member


    SomeClass(): DVar( 0 )    { memset( szString, 0, 32 ); };
    ~SomeClass(){};

    void    Increase( void ){ DVar++; };    
}

Now, you want a list of SomeClass elements. You declare it like this:

//

// somewhere in your application:

//


CLinkedListDouble<SomeClass, sinzeof(SomeClass)>    SomeClassList;

CLinkedListDouble

It's not a complex class... once you get to know it :).

template <class T, int i> 
class CLinkedListDouble
{
    CDebugTrace    Trace;        // used for debugging


    USHORT        Size;        // size of list


public:
    CLinkedListDoubleNode< T, i >    *pHead;        // head of list

    CLinkedListDoubleNode< T, i >    *pTail;        // tail of list

     // critical section object used to lock the list

    CNamedCriticalSection        Section;   
                            // this way using the list in a thread safe manner


    CLinkedListDouble();
    ~CLinkedListDouble();

    bool Initialize();        // initialize the list

    bool Free();            // release all elements of the list


    bool Add(T&);            // add new element to the head of list

    bool Remove(T&);        // remove element - by content

    bool Remove(USHORT);        // remove element - by position

    bool Insert(USHORT, T&);    // insert element in list


    USHORT GetSize(void);        // get the size of list

};

Normally, this may not be of your interest. This class is made to just "set it and use it".

One more thing. If you ever need to directly access the elements of the list - let's say you need to "walk" through all the elements and do something - remember to do this:

//

// somewhere in your application:

//


CLinkedListDouble<SomeClass, sinzeof(SomeClass)>    SomeClassList;

//

// somewhere else in your application (different thread for example)

//


CSpinLock    Spin( &(SomeClass.Section), "NoWhere" );
if( Spin.Lock() )
{
    //

    // direct access over list and elements data

    //

    
    ...

    Spin.Unlock();
}

Points of Interest

Anything involving double linked lists.

One more thing...

I'm not interested in ratings, edited article or any article competition. I never took in consideration any ratings when reading an article or downloading. I will not bother to answer messages like: "There is already an article like this here, and it's better...".

I just post here because CodeProject really helped me over the years, so I want to give back something. If something like this already exists here, on CodeProject... I do not really care. Use the one you want - it's your choice.

Anyway... I'll continue to post here!

History

• 28-february-2005

  version 1.0

  As promised, I've post it this one, too.