sh_queue.h

rsa算法打的一个包

// SH_Queue.h: interface for the SH_Queue class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_SH_QUEUE_H__80D8F99D_28F7_4711_839A_A8A4EB304719__INCLUDED_)
#define AFX_SH_QUEUE_H__80D8F99D_28F7_4711_839A_A8A4EB304719__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "SH_Object.h"

template<class ARG> 
class AFX_EXT_CLASS SH_Queue : public SH_Object
{
public: 
	SH_Queue();
	virtual ~SH_Queue();

    BOOL     Create(int nSize);
    BOOL     Resize(int nNewSize);
    
    BOOL     GetHead(ARG &  val);
    BOOL     GetTail(ARG &  val);
    
    BOOL     Append(ARG val);
    BOOL     RemoveHead(ARG &  val);
    BOOL     Prepend(ARG val);
    BOOL     RemoveTail(ARG &  val);

    int      GetSize()  const;
    int      GetCount() const;

    BOOL     IsEmpty();
    BOOL     IsFull();

private:
    int      m_nFront;
    int      m_nRear;
    int      m_nSize;
    int      m_nCount;
    ARG *    m_pQueue;
};
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
template<class ARG>
SH_Queue<ARG>::SH_Queue()
{
    m_nFront = -1;
    m_nRear  = -1;

    m_nSize  = 0;
    m_nCount = 0;
    m_pQueue = NULL;
} 

template<class ARG>
SH_Queue<ARG>::~SH_Queue()
{
    m_nSize  = 0;
    m_nCount = 0;

    SAFE_DELETE_ARRAY(m_pQueue);
} 

template<class ARG>
BOOL SH_Queue<ARG>::Create(int nSize)
{
    if(nSize < 1)
        return FALSE;

    if(m_nSize >0 )
        return FALSE;

    m_nSize = nSize;
    m_pQueue = new ARG[nSize];

    memset(m_pQueue,0,nSize * sizeof(ARG));

    return (m_pQueue != NULL);
}

template<class ARG>
BOOL SH_Queue<ARG>::Resize(int nNewSize)
{
    SAFE_DELETE_ARRAY(m_pQueue);

    m_nSize  = 0;
    m_nCount = 0;
    
    m_nFront = -1;
    m_nRear  = -1;

    return Create(nNewSize);
}

template<class ARG>
BOOL      SH_Queue<ARG>::GetHead(ARG &  val)
{
    if(m_nFront < 0)
        return FALSE;

    val = m_pQueue[m_nFront];
    return TRUE;
}

template<class ARG>
BOOL      SH_Queue<ARG>::GetTail(ARG &  val)
{
    if(m_nRear < 0)
        return FALSE;

    val = m_pQueue[m_nRear];
    return TRUE;
}

template<class ARG>
BOOL     SH_Queue<ARG>::Append(ARG val)
{
    if(IsFull())
        return FALSE;
    else
    {
        if(IsEmpty())
        {
            m_nFront = 0;
            m_nRear  = 0;
        }
        else
        {
            if(m_nRear == (m_nSize - 1))
                m_nRear = 0;
            else
                m_nRear ++;
        }
        m_pQueue[m_nRear] = val;
        m_nCount ++;
        return TRUE;
    }
}

template<class ARG>
BOOL     SH_Queue<ARG>::Prepend(ARG val)
{
    if(IsFull())
        return FALSE;
    else
    {
        if(IsEmpty())
        {
            m_nFront = 0;
            m_nRear  = 0;
        }
        else
        {
            if(m_nFront == 0)
                m_nFront = (m_nSize - 1);
            else
                m_nFront--;
        }
        m_pQueue[m_nFront] = val;
        m_nCount ++;
        return TRUE;
    }
}

template<class ARG>
BOOL     SH_Queue<ARG>::RemoveHead(ARG &  val)
{
    if(IsEmpty())
        return FALSE;

    val = m_pQueue[m_nFront];
    m_nCount--;

    if(m_nCount < 1)
    {
        m_nFront = -1;
        m_nRear  = -1;
    }
    else
    {
        if(m_nFront == (m_nSize -1))
            m_nFront = 0;
        else
            m_nFront ++;
    }
    return TRUE;
}

template<class ARG>
BOOL     SH_Queue<ARG>::RemoveTail(ARG &  val)
{
    if(IsEmpty())
        return FALSE;

    val = m_pQueue[m_nRear];
    m_nCount--;

    if(m_nCount < 1)
    {
        m_nFront = -1;
        m_nRear  = -1;
    }
    else
    {
        if(m_nRear == 0)
            m_nRear = m_nSize - 1;
        else
            m_nRear --;
    }
    return TRUE;
}

template<class ARG>
BOOL     SH_Queue<ARG>::IsEmpty()
{
    return m_nCount == 0;
}

template<class ARG>
BOOL SH_Queue<ARG>::IsFull()
{
    return (m_nCount == m_nSize);
}

template<class ARG>
AFX_INLINE int  SH_Queue<ARG>::GetSize()  const
{
    return m_nSize;
}

template<class ARG>
AFX_INLINE int      SH_Queue<ARG>::GetCount()  const
{
    return m_nCount;
}

#endif // !defined(AFX_SH_QUEUE_H__80D8F99D_28F7_4711_839A_A8A4EB304719__INCLUDED_)