обертка массива портит стек

мой проект представляет собой оболочку динамического массива, например std::vector. вот как это работает:

• при добавлении нового элемента память либо выделяется (malloc), если она 0, либо перераспределяется с новым размером (realloc), если она не 0. размер - количество элементов * размер типа

• при получении уже добавленного элемента вычисляю адрес, умножая его индекс на размер типа и прибавляя к адресу, по которому выделена память

ПРИМЕЧАНИЕ: я сам пишу и читаю память без каких-либо функций, таких как memcpy или memset. это необходимо для моего проекта. у меня должна быть возможность сделать это, поэтому, если вы можете, не упоминайте об этом (если я не реализовал это неправильно, в этом случае, пожалуйста, упомяните об этом)

когда я пытаюсь прочитать добавленный элемент с помощью функции get(int index), я получаю либо ошибку "стек вокруг переменной был поврежден", либо ошибку "нарушение доступа для чтения", в зависимости от того, как я пытаюсь это сделать.

я немного почитал в Интернете и обнаружил, что, возможно, каким-то образом испортил кучу с помощью malloc. также читал, что я мог узнать, где ошибка с чем-то под названием «valgrind», но, похоже, это доступно только для Linux, а я использую Windows.

вот мой код (он переписан, все проверки ошибок удалены, чтобы сделать его меньше). место, где я получаю сообщение об ошибке, комментируется:

template<class T>
class darr
{
public:
    darr(void) {}
    ~darr(void) {
        erase(); dealloc();
    }

    bool alloc(int elemc) {
        this->elemc = elemc;
        this->size = (elemc * sizeof(T));
        this->end = (this->start + this->size);

        if (this->start)
        {
            this->start = (T*)(realloc(this->start, this->size));

            if (this->start)
            {
                this->end = (this->start + this->size);
                return true;
            }
        }
        else
        {
            this->start = (T*)(malloc(this->size));

            if (this->start)
            {
                this->end = (this->start + this->size);
                return true;
            }
        }

        return false;
    }

    bool erase(void)
    {
        for (int i = 0; i <= this->size; ++i)
        {
            *(unsigned long*)(this->start + i) = 0;
        }

        return true;
    }

    bool dealloc(void)
    {
        free(this->start);

        return true;
    }

    bool add(T obj)
    {
        void* end_temp = 0;

        if (this->end) { end_temp = this->end; }

        if (true == this->alloc(++this->elemc))
        {
            end_temp = this->end;

            for (int i = 0; i <= sizeof(obj); ++i)
            {
                *(unsigned long*)((unsigned long)(end_temp)+i) = *(unsigned long*)((unsigned long)(&obj) + i);
            }
        }

        return true;
    }

    T get(int i)
    {
        unsigned long siz = sizeof(T);
        void* i_addr = this->start + (i * siz);

        //T tempobj = 0;
        T* tempobj = (T*)(malloc(sizeof(T)));
        // without malloc - stack around var corrupted (happnens at last index in for loop, no matter what index it is)
        // with malloc - read access violation
        for (int i = 0; i <= siz; ++i)
        {
            *(unsigned long*)((unsigned long)(&tempobj)+i) = *(unsigned long*)((unsigned long)(i_addr)+i);
        }

        return *tempobj;
    }
private:
    T * start;
    void* end;
    int elemc, size;
};