void reserve(size_t new_capacity)
{
  char* old_buf = buf_;
  buf_ = new char[new_capacity*sizeof(T)]; // если new бросает - в объекте ничего не меняется
  capacity_ = new_capacity;
  const size_t orig_size = size_;
  size_=0;
  // итак, сейчас у нас buf_ указывает на нововыделенный пустой буфер
  // capacity соответствует его размеру и size_ нулевой (так как ничего в буфере нету)
  // Т.е. вектор уже в рабочем состоянии (пустой), базовая гарантия в плане инвариантов
  // УЖЕ выполнена (я ведь обещал, что это элементарно?)

  // Осталось разобраться с утечками.
  // Для этого в конце, независимо ни от чего, прибиваем old_buf со всем содержимым
  // (этот прибиватор вполне себе общего назначения и его можно объявить и снаружи):
  struct OnScopeExit {
    char* old_buf;
    size_t orig_size;
    ~OnScopeExit() {
      for (size_t i=0; i<orig_size; ++i) ((T&)( old_buf[i*sizeof(T)] )).~T();
      delete[] old_buf;
    }
  } on_scope_exit = { old_buf, orig_size };
  // все, базовая гарантия достигнута полностью, можно начинать изгаляться над буфером

  // попробуем покопировать, нехай исключения летят
  for (; size_<orig_size; ++size_)
    new (&buf_[size_*sizeof(T)]) T(std::move( (T&)old_buf[size_*sizeof(T)] ));
  // по окончании работы функции size_ показывает количество успешно скопированных объектов
}

ERR_CODE reserve( size_t new_capacity )
E>{
E>    ERR_CODE res = EC_Ok;  // это мантра ;)
E>    if( new_capacity <= capacity_ ) { // Этого у тебя не было, но положим, 
// что ты про это забыл потому что код очень простой и понятный ;)
E>        return res;
E>    }

E>    assert( new_capacity > 0 ); 

E>    // Создаём копию буфера, и передвигаем в неё данные
E>    char* extra_buf = new char[new_capacity*sizeof(T)] );
E>    if( extra_buf == 0 ) {
E>        return EC_MemoryError;
E>    }
    
E>    size_t cp_size = 0;
E>    while( cp_size < size() && IsOk( res ) ) {
E>        res = move_array_item( ((T*)extra_buf)[cp_size], ((T*)buf_)[cp_size] );
E>    }
E>    // тут мы ещё можем решить, что разрушать. Например, можно разрушать
      // старый буффер только если полностью получилось скопировать новый
E>    if( IsOk( res ) ) {
E>        std::swap( extra_buf, buf_ );
E>        std::swap( size_, cp_size );
E>        capacity_ = new_capaciry;
E>    }

E>    while( cp_size  > 0 ) {
E>        ( --cp_size + (T*)extra_buf )->~T();  // Разрушаю всё-таки с конца...
E>    }  
E>    delete[] extra_buf;
E>    return res;
E>}

template<typename T> void destroy_array_of_items( T* dst, size_t count ) 
E>{
E>    while( count > 0 ) {
E>        ( dst + --count )->~T();
E>    }
E>}

J>void g() {
J>  ...
J>  throw x;
J>  ...
J>}
J>void f() {
J>  ...
J>  g();
J>  ...
J>}

J>int main() {
J>  try {
J>    ...
J>    f();
J>    ...
J>  } catch(exception e) {
J>    ...
J>  }
J>}
J>

J>exception current_exception = NULL;

J>void g() {
J>  ...
J>  current_exception = x;
J>  return;
J>  ...
J>}

J>void f() {
J>  ...
J>  g();
J>  if (current_exception) return;
J>  ...
J>}

J>int main() {
J>  do { // чисто чтоб goto не писать
J>    ...
J>    f();
J>    if (current_exception) break;
J>    ...
J>  } while(false);
J>  if (current_exception) {
J>    ...
J>    current_exception = NULL;
J>  }
J>}
J>

J>>. . .
J>>void g() {
J>>  ...
     if (current_exception) std::terminate();
J>>  current_exception = x;
J>>  return;
J>>  ...
J>>}
J>>. . .
I>