Stack Management without vector

[Dr.Junkie]

Code: [Select]

/*
      Coded by Dr.Junkie @ evilzone.org
*/
template <typename T>
class CStackManager
{
private:
    T* m_pStack = NULL;
    int m_iSize;
public:
    void push_back(T &Data);
    T pop_back(int iIndex);
    T get_value(int iIndex);
};

template<typename T>
void CStackManager<T>::push_back(T &Data)
{
    if (m_pStack == NULL)
    {
        m_pStack = (T*)malloc(sizeof(T));
        m_pStack[0] = Data;
        m_iSize = 1;
    }
    else
    {
        m_iSize += 1;
        m_pStack = (T*)memrealloc(m_pStack, m_iSize * sizeof(T));
        m_pStack[m_iSize - 1] = Data;
    }
}

template<typename T>
T CStackManager<T>::pop_back(int iIndex)
{
    T Data = NULL;

    if (m_iSize > 1)
    {
        int iNewSize = 0;

        T* pStack = (T*)malloc(m_iSize * sizeof(T));
       
        for (unsigned int i = 0; i < m_iSize; i++)
        {
            if (iIndex == i)
                continue;

            int iNewIndex = i;

            if (i > iIndex)
                iNewIndex -= 1;

            pStack[iNewIndex] = m_pStack[i];

            iNewSize++;

        }

        Data = m_pStack[iIndex];
        m_pStack = pStack;

        m_iSize = iNewSize;
    }
    else
    {
        Data = m_pStack[iIndex];
        ZeroMemory(m_pStack, sizeof(T) * 1);
        m_iSize = 0;
    }

    return Data;
}

template<typename T>
T CStackManager<T>::get_value(int iIndex)
{
    return m_pStack[iIndex];
}

[ArkPhaze]

push_back and pop_back semantically mean something completely unrelated to a LIFO stack to me, by how they operate in multiple STL containers. What they really should probably say are push_top, and pop_top, if you don't just name them push and pop for the way most people recognize the stack operations...

My first question to you is why do you NOT properly free this memory block you've allocated for the stack operations on the heap? My second question is why do you use malloc() in C++? You should be using the new and delete keywords.

This is a good example of the reason why dynamic memory allocation is typically avoided in C++ at high level. The workings of your class are a basic example of a semi-working stack datatype, but it also introduces the possibility of memory leaks. You should have a defined destructor which takes care of freeing up that memory you allocate with malloc() in this case.