Class DfArray

library/include/BitArray.h:212–281

    template <typename T = int>
    class DfArray
    {
    private:
        T *m_data;
        unsigned short m_size;

        void resize(unsigned short new_size, const DfArray<T>* replacement)
        {
            if (new_size == m_size)
                return;

            T* old_data = m_data;

            m_data = (T*) new T[new_size];

            T* copysrc = replacement ? replacement->m_data : old_data;
            unsigned short copysize = replacement ? replacement->m_size : m_size;

            if (copysrc)
                std::memcpy(m_data, copysrc, sizeof(T) * std::min(copysize, new_size));

            if (new_size > m_size)
                std::memset(m_data + m_size, 0, sizeof(T) * (new_size - m_size));

            delete[] old_data;

            m_size = new_size;
        }
    public:
        DfArray() : m_data(nullptr), m_size(0) {}
        ~DfArray() { delete[] m_data; }

        DfArray(const DfArray<T> &other) : m_data(nullptr), m_size(0)
        {
            resize(other.m_size, &other);
        }

        typedef T value_type;

        T *data() { return m_data; }
        const T *data() const { return m_data; }
        unsigned size() const { return m_size; }

        T *begin() { return m_data; }
        T *end() { return m_data+m_size; }

        T& operator[] (unsigned i) { return m_data[i]; }
        const T& operator[] (unsigned i) const { return m_data[i]; }

        void resize(unsigned new_size)
        {
            resize(new_size, nullptr);
        }

        DfArray &operator= (const DfArray<T> &other)
        {
            resize(other.size(), &other);
            return *this;