Как работает vector?

#include <iostream>
int size = 0;
template<class type>
class t{
private:
  
  struct obj
  {
    type * t;
    obj * next;
  };
 
  obj * first = new obj;
  obj * last = new obj;
  
 public :
 ~ t(){
    obj * q = first;
    for(int i = 0; i < size; i ++){
      obj * o = q->next;
      std::cout << q<< std::endl;
      delete q;
      q = o;
    }
  }
 void add(type ob){
   if(size == 0){
     last->t = &ob;
     first = last;
     std::cout << first << std::endl;
     size++;
   }
   else
   {
     obj * o = new obj;
     std::cout << o << std::endl;
     o->t = &ob;
     last->next = o;
     last = o;
     size++;
   }
 }
  type& operator[](int num){
    obj * q = first;
    for(int i = 0; i < num-1; i ++){
      q = q->next;
    }
    return *q->t;
  }
};
int main(){
  t<int>vec;
  int a = 6;
  int q = 153;
  std::cout << sizeof(vec) << std::endl;
   for(int i = 0;i <5;i++ ){
     vec.add((int)i);
   }
   for(int x = 1;x <=5;x++ ){
      std::cout << vec[x]  << std::endl;
   }
  return 0; 
}

template< typename T >
class kvector 
{
public:
    typedef T* iterator;
    typedef const T* const_iterator;
 
    kvector() 
    {
        _init(0);
    }
 
    kvector(size_t size) 
    {
        _init(size);
    }
    
    kvector(const kvector<T>& other)
    {
        _init(other.size()); 
        _copy_buf(m_buf, other.m_buf, other.size());
    }
    
    kvector(const_iterator begin, const_iterator end)
    {
        const size_t size = end - begin;
        _init(size); 
        _copy_buf(m_buf, begin, size);
    }
    
    kvector(kvector<T>&& other)
    {
        _move(other);
    }
 
    ~kvector() 
    {
       _free_all();
    }
    
    kvector<T>& operator=(const kvector<T>& other)
    {
        if (this != &other)
        {
            if (m_allocSize < other.size())
            {
                _free_all();
                _init(other.size()); 
            }
            else
            {
                if (m_size > other.m_size)
                    _destruct(&m_buf[other.m_size], m_size - other.m_size);
                m_size = other.m_size;
            }
            _copy_buf(m_buf, other.m_buf, other.size());
        }
        return *this;
    }
    
    kvector<T>& operator=(kvector<T>&& other)
    {
        if (this != &other)
        {
            _free_all();
            _move(other);
        }
        return *this;
    }
    
    T* data()
    {
        return m_buf;
    }
    
    T* data() const
    {
        return m_buf;
    }
 
    size_t size() const 
    {
        return m_size;
    }
 
    void push_back(const T& item) 
    {
        if (m_size == m_allocSize) 
            reserve(max(m_allocSize * 2, m_defaultSize));
        new (&m_buf[m_size++]) T(item);
    }
 
    T& operator[](const size_t idx) 
    {
        return m_buf[idx];
    }
 
    const T& operator[](const size_t idx) const 
    {
        return m_buf[idx];
    }
 
    const iterator begin() const 
    {
        return &m_buf[0];
    }
 
    const iterator end() const 
    {
        return &m_buf[m_size];
    }
 
    bool empty() const 
    {
        return (m_size == 0);
    }
 
    T& front() const 
    {
        return m_buf[0];
    }
 
    T& back() const 
    {
        return m_buf[m_size - 1];
    }
 
    void pop_back() 
    {
        _destruct(&m_buf[--m_size], 1);
    }
 
    void clear() 
    {
        _destruct(m_buf, m_size);
        m_size = 0;
    }
 
    void clear_and_free() 
    {
        _free_all();
        _init(0);
    }
 
    void resize(size_t size) 
    {
        reserve(size);
        if (size < m_size)
            _destruct(&m_buf[size], m_size - size);
        else if (size > m_size)
            _construct(&m_buf[m_size], size - m_size);
        m_size = size;
    }
    
    void reserve(size_t size)
    {
        if (size > m_allocSize) 
        {
            auto tmp = _alloc(size);
            if (m_buf != nullptr)
            {
                _move_buf(tmp, m_buf, m_size);
                _free_all();
            }
            m_buf = tmp;
            m_allocSize = size;
        }
    }
 
private:
    T* m_buf;
    size_t m_allocSize;
    size_t m_size;
    static const size_t m_defaultSize = std::is_trivial<T>::value ? 16 : 1;
 
private:
    T* _alloc(size_t size)
    {
        return reinterpret_cast<T*>(new char[size * sizeof(T)]);
    }
    
    void _free(T* p)
    {
        delete[] reinterpret_cast<char*>(p);
    }
    
    template<typename DestructType>
    void _destruct(DestructType* p, size_t size,
        typename std::enable_if<!std::is_trivial<DestructType>::value>::type* = nullptr)
    {
        for (size_t i = 0; i < size; i++)
            p[i].~T();
    }
    
    template<typename DestructType>
    void _destruct(DestructType*, size_t,
        typename std::enable_if<std::is_trivial<DestructType>::value>::type* = nullptr)
    {
    }
    
    template<typename ConstructType>
    void _construct(ConstructType* p, size_t size,
        typename std::enable_if<!std::is_trivial<ConstructType>::value>::type* = nullptr)
    {
        for (size_t i = 0; i < size; ++i)
            new (&p[i]) T;
    }
    
    template<typename ConstructType>
    void _construct(ConstructType*, size_t,
        typename std::enable_if<std::is_trivial<ConstructType>::value>::type* = nullptr)
    {
    }
    
    void _free_all()
    {
        if (m_buf != nullptr)
        {
            _destruct(m_buf, m_size);
            _free(m_buf);
        }
    }
    
    void _init(size_t size) 
    {
        m_buf = (size > 0) ? _alloc(size) : nullptr;
        m_allocSize = size;
        m_size = size;
        _construct(m_buf, size);
    }
    
    void _move(kvector<T>& other) 
    {
        m_buf = other.m_buf;
    m_allocSize = other.m_allocSize;
        m_size = other.m_size;
        other._init(0);
    }
    
    template<typename CopyType>
    void _move_buf(CopyType* to, CopyType* from, size_t size, 
        typename std::enable_if<std::is_trivial<CopyType>::value>::type* = nullptr)
    {
        memcpy(to, from, size * sizeof(CopyType));
    }
    
    template<typename CopyType>
    void _move_buf(CopyType* to, CopyType* from, size_t size, 
        typename std::enable_if<!std::is_trivial<CopyType>::value>::type* = nullptr)
    {
        while(size--)
        {
            new (to) T(std::move(*from));
            to++;
            from++;
        }
    }
    
    template<typename CopyType>
    void _copy_buf(CopyType* to, const CopyType* from, size_t size, 
        typename std::enable_if<std::is_trivial<CopyType>::value>::type* = nullptr)
    {
        memcpy(to, from, size * sizeof(CopyType));
    }
    
    template<typename CopyType>
    void _copy_buf(CopyType* to, const CopyType* from, size_t size, 
        typename std::enable_if<!std::is_trivial<CopyType>::value>::type* = nullptr)
    {
    copy(from, from + size, to);
    }
};

template <typename T>
class CSingleLinkedList
{
public:
    struct CNode
    {
        CNode(T val)
        : m_val(std::move(val))
        {
        }
 
        T m_val;
        CNode *m_next = nullptr;
    };
 
    ~CSingleLinkedList()
    {
        while (m_head)
            delete std::exchange(m_head, m_head->m_next);
    }
 
    void push_back(T val)
    {
        CNode *node = new CNode(std::move(val));
        if (!m_head)
            m_head = m_tail = node;
        else
            m_tail = m_tail->m_next = node;
    }
 
    std::unique_ptr<CNode> pop_front()
    {
        if (!m_head)
            return nullptr;
 
        std::unique_ptr<CNode> sp(m_head);
        m_head = m_head->m_next;
        if (!m_head)
            m_tail = nullptr;
        return sp;
    }
    
protected:
    CNode *m_head = nullptr;
    CNode *m_tail = nullptr;
};