Implementacja std::vector – code review

template <class T>
class List {
private:
    int length;
    int capacity;
    int log;
    T *buffer;

    void reserve(int capacity) {
        T *newBuffer = new T[capacity];
        memcpy(newBuffer, buffer, length*sizeof(T));
        delete[] buffer;
        buffer = newBuffer;
        this->capacity = capacity;
    }
public:
    List() {
        length = capacity = log = 0;
        buffer = nullptr;
    }
    List(const List<T> &list) {
        length = list.length;
        log = list.log;
        capacity = list.capacity;
        buffer = new T[capacity];
        memcpy(buffer, list.buffer, length*sizeof(T));
    }
    List(int capacity) {
        log = (int)(Math::ceil(Math::log2(capacity))+0.5)+1; //W ten sposób w najgorszym przypadku, czyli np. log2(4) = 2.001, zostanie zarezerwowane 2 razy więcej pamięci niż to potrzebne. (int)(ceil()+0.5) nie pozwala ceil() na zwrócenie wartości mniejszej niż oczekiwana, czyli gdy ceil(1.5) = 1.999, jest to zamieniane na 2.
        this->capacity = 0b1 << (log-1);
        buffer = new T[this->capacity];
        length = 0;
    }

    inline T &operator[](int index) {
        return buffer[index];
    }

    T *begin() { return buffer; }
    T *end() { return buffer + length; }
    T &front() { return buffer[0]; }
    T &back() { return buffer[length - 1]; }
    int size() {
        return length;
    }
    bool empty() {
        return length == 0;
    }
    void clear() {
        length = capacity = log = 0;
        delete[] buffer;
        buffer = nullptr;
    }
    int find(const T &element) {
        for(int i=0; i<length; i++) {
            if(buffer[i] == element)return i;
        }
        return -1;
    }
    void add(const T &element) {
        if(length == capacity)reserve(0b1 << log++);
        buffer[length++] = element;
    }
    void remove(int index) {
        if(index < 0)return; //Tutaj UB jest jak najbardziej wskazane - jak programista użyje, tak dostanie. Sprawdzanie  czy liczba jest ujemna ma jedynie umożliwić użycie List::remove(List::find(const T &))
        T *i = &buffer[index];
        memcpy(i, i+1, (--length-index)*sizeof(T));
        delete i;
    }

    ~List() {
        delete[] buffer;
    }
};

{
  List list;
}

{
  List list{10};
  list.clear();
}

template <class T>
class List {
public:
    int size;
    int capacity;
    T *buffer;

    void copy(T *dst, T *src, int size) {
        for(int i=0; i<size; i++) {
            dst[i] = src[i];
        }
    }
    void reserve(int capacity) {
        T *newBuffer = new T[capacity];
        copy(newBuffer, buffer, size);
        delete[] buffer;
        buffer = newBuffer;
        this->capacity = capacity;
    }
public:
    List() {
        size = 0;
        capacity = 1;
        buffer = new T[capacity];
    }
    List(const List<T> &list) {
        size = list.size;
        capacity = list.capacity;
        buffer = new T[capacity];
        copy(buffer, list.buffer, size);
    }

    inline List<T> &operator=(const List<T> &rhs) {
        size = rhs.size;
        capacity = rhs.capacity;
        delete[] buffer;
        buffer = new T[capacity];
        copy(buffer, rhs.buffer, size);
        return *this;
    }
    inline T operator[](int rhs) const {
        return buffer[rhs];
    }
    inline T &operator[](int rhs) {
        return buffer[rhs];
    }

    T *begin() { return buffer; }
    T *end() { return buffer + size; }
    T &front() { return buffer[0]; }
    T &back() { return buffer[size - 1]; }
    T *data() {
        return buffer;
    }
    int length() {
        return size;
    }
    void clear() {
        size = 0;
        capacity = 1;
        delete[] buffer;
        buffer = new T[capacity];
    }
    int find(const T &element) {
        for(int i=0; i<size; i++) {
            if(buffer[i] == element)return i;
        }
        return -1;
    }
    void add(const T &element) {
        if(size == capacity)reserve(2 * capacity);
        buffer[size++] = element;
    }
    void remove(int index) {
        if(index < 0)return;
        T *i = &buffer[index];
        copy(i, i+1, (--size-index));
        delete i;
    }

    ~List() {
        delete[] buffer;
    }
};