strong safety

#include <initializer_list>
#include <iostream>
template <typename T>
class vector{

public:
    vector(size_t size): sz_(size), arr_(new T[size]){
        for(int i = 0; i < size; ++i){
            arr_[i] = 0;
        }
    }

    vector(std::initializer_list<T> lst_): sz_(lst_.size()), arr_(new T[sz_]){
        std::copy(lst_.begin(), lst_.end(), arr_); //заполняем elem_ элементами из списка инициализации elem_[i] = 25 и тд.
    }

    void reserve(size_t newcap){

        if(newcap <= cap_){
            return;
        }

        T* newarr = reinterpret_cast<T*>(new char[newcap*sizeof(T)]); //Если нет reinter, то не получится добавить кроме char* ничего.
        size_t index = 0;
        try{
            for(; index < sz_; ++index){
                //newarr[index] = arr_[index]; UB, потому что newarr - не инициализировано. а это ссылка.
                new(newarr + index) T(arr_[index]); //placementnew Вызвать конструктор типа по данному адресу.
            }
        } catch(...){
            for(size_t oldindex = 0; oldindex < index; ++oldindex){
                (newarr+oldindex)->~T();
            }
            delete[] reinterpret_cast<char*>(newarr);
            throw;
        }
            /*Компилятор попробует освободить память, на которую указывает (arr_ + index).
            Но я никогда не выделял эту память через new, поэтому он не знает, как это сделать.*/
        for(size_t index = 0; index < sz_; ++index){
            (arr_+index)->~T(); // когда мы выделяем память вручную new char[] компилятор не сможет ими управлять, поэтому удалять приходится самостоятельно
        }
        delete[] reinterpret_cast<char*>(arr_); //Преобразует указатель arr_ обратно к типу char*, который указывает на исходный блок сырой памяти.
                                                    //Указывает компилятору освободить всю выделенную память.
        arr_ = newarr;
        cap_ = newcap;
        // memcpy запрещено, потому что не переживёт тип, который имеет тип поля ссылку на другое поле.
    }

    void push_back(size_t value){
        if(sz_ >= cap_){
            reserve(sz_*2);

            T* newarr = reinterpret_cast<T*>(new char[cap_*sizeof(T)]);
            try{

                size_t index = 0;
                for(; index < sz_; ++index){
                    new (arr_ + index) T(arr_[index]);
                }
                new (arr_+sz_) T(value);

            }catch(...){
                for(size_t oldindex = 0; oldindex < sz_; ++oldindex){
                    (newarr+oldindex)->~T();
                }
                delete[] reinterpret_cast<char*>(newarr);
                throw;
            }

            for(size_t index = 0; index < sz_; ++index){
                    (newarr+index)->~T();
            }
            delete[] reinterpret_cast<char*>(newarr);

            arr_ = newarr;

        }
        else{
            new (arr_+sz_) T(value);
        }
        ++sz_;
    }

    size_t size() const{
        return sz_;
    }

private:
    size_t cap_;
    size_t sz_;
    T* arr_;

};