1. Accueil
  2. C / C++ / C++.NET
  3. Sources C / C++ / C++.NET
  4. Sources Maths & Algorithmes
  5. Template de queue ou file d?attente

Template de queue ou file d?attente

Soyez le premier à donner votre avis sur cette source.

Vue 7 163 fois - Téléchargée 292 fois

Télécharger le projet
Commenter

Description

Template de queue ou file d?attente.

Pour l'utiliser c'est tout simple il suffit d'inclure BQueue.h.

Source / Exemple : 


#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

Conclusion :


Pour les mises à jour consultez mon site http://perso.club-internet.fr/sfeldis. Pour une explication visitez http://perso.club-internet.fr/sfeldis/langages/c++/bstack/mainFrame.html.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (phenix13)