Hardwired's Thread Safe Double Link List Template






1.24/5 (12 votes)
Feb 28, 2005
2 min read

35370

354
This article explains how to use CLinkedListDouble template class. This template is a thread safe implementation of double link list.
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.