sh_stack.h

rsa算法打的一个包

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

#if !defined(AFX_SH_STACK_H__80D8F99D_28F7_4711_839A_A8A4EB304719__INCLUDED_)
#define AFX_SH_STACK_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_Stack : public SH_Object
{
public: 
	SH_Stack();
	virtual ~SH_Stack();

    BOOL     Create(int nSize);
    BOOL     Resize(int nNewSize);

    BOOL     Push(ARG val);
    ARG      Pop(VOID);
    ARG      Top(VOID);

    BOOL     IsFull(VOID);
    BOOL     IsEmpty(VOID);

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

private:
    int      m_nSize;
    int      m_nCount;
    ARG *    m_pStack;
};
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
template<class ARG>
SH_Stack<ARG>::SH_Stack()
{
    m_nSize  = 0;
    m_nCount = 0;
    m_pStack = NULL;
} 

template<class ARG>
SH_Stack<ARG>::~SH_Stack()
{
    m_nSize  = 0;
    m_nCount = 0;
    if(m_pStack)
    {
        delete [] m_pStack;
        m_pStack = NULL;
    }
} 

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

    if(m_nSize >0 )
        return FALSE;

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

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

    return (m_pStack != NULL);
}

template<class ARG>
BOOL SH_Stack<ARG>::Resize(int nNewSize)
{
    if(m_pStack)
    {
        delete [] m_pStack;
        m_pStack = NULL;
        m_nSize  = 0;
        m_nCount = 0;
    }

    return Create(nNewSize);
}

template<class ARG>
BOOL     SH_Stack<ARG>::Push(ARG val)
{
    if(!IsFull())
    {
        m_pStack[m_nCount++] = val;
        return TRUE;
    }
    return FALSE;
}

template<class ARG>
ARG      SH_Stack<ARG>::Pop(VOID)
{
    ARG val = NULL;

    if(!IsEmpty())
    {
        val = m_pStack[m_nCount-1];
        m_nCount--;
    }

    return val;
}

template<class ARG>
ARG      SH_Stack<ARG>::Top(VOID)
{
    ARG val = NULL;

    if(!IsEmpty())
    {
        val = m_pStack[m_nCount-1];
    }
}

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

template<class ARG>
BOOL     SH_Stack<ARG>::IsEmpty(VOID)
{
    return (m_nCount < 1);
}

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

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

#endif // !defined(AFX_SH_STACK_H__80D8F99D_28F7_4711_839A_A8A4EB304719__INCLUDED_)