Re: ArrayStack<T> using placement new

On Mar 13, 10:03 pm, Hakusa <Hak...@gmail.com> wrote:


For illustration purposes I stripped down ArrayStack to the essentials
and removed external dependencies, and wrote a quick test:

The test push_backs 1,000,000 elements onto the container class under
test.

ArrayStack calls the constructor and destructor exactly 1,000,000
times.

std::vector calls the constructor and destructor over 3,000,000
times.

If it is safe to binary move T, ArrayStack is far more efficient than
std::vector.

=============================
         TEST OUTPUT
=============================
std::vector<T>: s_iDefaultConstructions = 0
std::vector<T>: s_iCopyConstructions = 3099753
std::vector<T>: s_iDestructions = 3099753
ArrayStack<T>: s_iDefaultConstructions = 0
ArrayStack<T>: s_iCopyConstructions = 1000000
ArrayStack<T>: s_iDestructions = 1000000

=============================
         TEST PROGRAM
=============================

#include <vector>

class X
{
public:
    static int s_iDefaultConstructions;
    static int s_iCopyConstructions;
    static int s_iDestructions;

    static void reset()
    {
        s_iDefaultConstructions = 0;
        s_iCopyConstructions = 0;
        s_iDestructions = 0;
    }

    static void dump(const char* s)
    {
        printf("%s: s_iDefaultConstructions = %d\n", s,
            s_iDefaultConstructions);
        printf("%s: s_iCopyConstructions = %d\n", s,
            s_iCopyConstructions);
        printf("%s: s_iDestructions = %d\n", s,
            s_iDestructions);
    }

    X() { s_iDefaultConstructions++; }
    X(const X&) { s_iCopyConstructions++; }
    ~X() { s_iDestructions++; }
};

int X::s_iDefaultConstructions;
int X::s_iCopyConstructions;
int X::s_iDestructions;

template <class Container>
void test(const char* sContainerName)
{
    X x;

    X::reset();
    {
        Container v;
        for (int i = 0; i < 1000000; i++)
        {
            v.push_back(x);
        }
    }
    X::dump(sContainerName);
}

template <class T>
class ArrayStack
{
public:
         ArrayStack()
                 : m_p((T*)malloc(0))
                 , m_iNumItems(0)
        , m_iCapacity(0)
         {}

         void push_back(const T& t)
         {
                 if (m_iNumItems == m_iCapacity)
                         setCapacity((m_iCapacity << 1) + 1);

                 new (m_p + m_iNumItems++) T(t);
         }

         ~ArrayStack()
         {
                 for (int i = 0; i < m_iNumItems; i++)
                         m_p[i].~T();

        free(m_p);
         }

         void setCapacity(int iCapacity)
    {
        m_iCapacity = iCapacity;
        m_p = (T*) realloc((T*)m_p, iCapacity * sizeof(T));
    }

    T* m_p;
         int m_iNumItems;
    int m_iCapacity;
};

int main(int argc, char** argv)
{
    test< std::vector<X> > ("std::vector<T>");
    test< ArrayStack<X> > ("ArrayStack<T>");
}

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]