TEMPLATE DE QUEUE OU FILE D?ATTENTE

#ifndef __BQUEUE_H__
#define __BQUEUE_H__

// Revision history
// -------------------
//
// 1.0.0 First release

#pragma once

#include <assert.h>

template <class T> class BQueue
{
protected:
	struct	sQueueItem
	{
		T			item;
		sQueueItem	*pNextItem;
	};

	sQueueItem	*_pFirstItem;
	sQueueItem	*_pLastItem;
	DWORD		_nCount;

	void		copyQueue(const BQueue<T> &queue);

public:
				BQueue();
				BQueue(const BQueue<T> &queue);
	virtual		~BQueue();

	// Enqueues an item to the tail of the queue.
	//
	// [in] const T &newItem : item to enqueue.
	void		Enqueue(const T &newItem);
	// Dequeues an item of the head of the queue.
	//
	// Returns the dequeued item.
	T			Dequeue();
	
	// Removes all items of the queue.
	void		RemoveAll();

	// Returns TRUE if the queue is empty, FALSE otherwise.
	BOOL		IsEmpty();
	// Returns the item count of the queue.
	DWORD		Count();

	BQueue<T>	&operator = (const BQueue<T> &queue);
};

template <class T> void BQueue<T>::copyQueue(const BQueue<T> &queue)
{
	sQueueItem	*pItem;
	
	RemoveAll();

	for(pItem=queue._pFirstItem ; pItem!=NULL ; pItem=pItem->pNextItem)
		Enqueue(pItem->item);
}

template <class T> BQueue<T>::BQueue()
{
	_pFirstItem=NULL;
	_pLastItem=NULL;
	_nCount=0;
}

template <class T> BQueue<T>::BQueue(const BQueue<T> &queue)
{
	_pFirstItem=NULL;
	_pLastItem=NULL;
	_nCount=0;

	copyQueue(queue);
}

template <class T> BQueue<T>::~BQueue()
{
	RemoveAll();
}

template <class T> void BQueue<T>::Enqueue(const T &newItem)
{
	sQueueItem	*pNewItem=new sQueueItem;

	pNewItem->item=newItem;
	pNewItem->pNextItem=NULL;
	if(_pLastItem!=NULL)
		_pLastItem->pNextItem=pNewItem;
	_pLastItem=pNewItem;
	if(_pFirstItem==NULL)
		_pFirstItem=pNewItem;

	_nCount++;
}

template <class T> T BQueue<T>::Dequeue()
{
	assert(_nCount && _pFirstItem!=NULL && _pLastItem!=NULL);
	
	sQueueItem	*pPopedItem=_pFirstItem;
	T			item=pPopedItem->item;

	if(_pFirstItem==_pLastItem)
		_pLastItem=NULL;
	_pFirstItem=_pFirstItem->pNextItem;
	delete pPopedItem;

	_nCount--;

	return item;
}

template <class T> void BQueue<T>::RemoveAll()
{
	while(_nCount)
		Dequeue();
}

template <class T> BOOL BQueue<T>::IsEmpty()
{
	return !_nCount;
}

template <class T> DWORD BQueue<T>::Count()
{
	return _nCount;
}

template <class T> BQueue<T> &BQueue<T>::operator = (const BQueue<T> &queue)
{
	copyQueue(queue);

	return *this;
}

#endif 

Télécharger le zip