A vecor<> that grows by doubling its capacity for MSVC

I didn't understand why Microsoft decided to grow the capacity of
a  vector only by 50% when needed. libstdc++ and libc++ increase
the capacity by 100%. And C#'s ArrayList is also implemented with
100%-growing.
So I modified VC++'s vector<> to multiply it's capacity by 2^N
according to the destination capcacity. Take a look at the function
complexReCap, which does the ticky part without looping to calculate
the final capacity.
#pragma once
#include <vector>
#include <iterator>
#include <type_traits>
#include <utility>
#include <bit>
#include <cassert>
#include <ranges>
#if defined(_MSC_VER)
template<typename Range, typename T>
concept d_vector_range = std::forward_iterator<decltype(Range().begin())>
&& requires( Range rg ) { { rg.begin() != rg.end() } -> std::convertible_to<bool>; }
&& std::convertible_to<decltype(*Range().begin()), T>;
template<typename T, typename Alloc = std::allocator<T>>
struct d_vector : public std::vector<T, Alloc>
{
using super = std::vector<T, Alloc>;
using iterator = super::iterator;
using value_type = super::value_type;
using reference = super::reference;
using size_type = super::size_type;
using const_iterator = super::const_iterator;
using super::vector;
constexpr iterator insert( const_iterator pos, value_type const &value );
constexpr iterator insert( const_iterator pos, value_type &&value );
constexpr iterator insert( const_iterator pos, size_type count, value_type const &value );
template<std::input_iterator InputIt>
constexpr iterator insert( const_iterator pos, InputIt first, InputIt last )
requires std::convertible_to<std::iter_value_t<InputIt>, value_type>;
constexpr iterator insert( const_iterator pos, std::initializer_list<T> ilist );
template<typename ... Args>
requires std::is_constructible_v<T, Args ...>
constexpr iterator emplace( const_iterator pos, Args &&... args );
constexpr void push_back( T const &value );
constexpr void push_back( T &&value );
template<typename ... Args>
requires std::is_constructible_v<T, Args ...>
constexpr reference emplace_back( Args &&... args );
#if defined(__cpp_lib_containers_ranges)
template<typename Range>
requires d_vector_range<Range, T>
constexpr void assign_range( Range &&rg );
template<typename Range>
requires d_vector_range<Range, T>
constexpr iterator insert_range( const_iterator pos, Range &&rg );
template<typename Range>
requires d_vector_range<Range, T>
constexpr void append_range( Range &&rg );
#endif
private:
void incr( size_t n );
void reCap( size_t required );
void complexReCap( size_t required, size_t cap );
};
template<typename T, typename Alloc>
constexpr typename d_vector<T, Alloc>::iterator d_vector<T, Alloc>::insert( const_iterator pos, value_type const &value )
{
incr( 1 );
return super::insert( pos, value );
}
template<typename T, typename Alloc>
constexpr typename d_vector<T, Alloc>::iterator d_vector<T, Alloc>::insert( const_iterator pos, value_type &&value )
{
incr( 1 );
return super::insert( pos, std::move( value ) );
}
template<typename T, typename Alloc>
constexpr typename d_vector<T, Alloc>::iterator d_vector<T, Alloc>::insert( const_iterator pos, size_type count, value_type const &value )
{
incr( count );
return super::insert( pos, count, value );
}
template<typename T, typename Alloc>
template<std::input_iterator InputIt>
constexpr typename d_vector<T, Alloc>::iterator d_vector<T, Alloc>::insert( const_iterator pos, InputIt first, InputIt last )
requires std::convertible_to<std::iter_value_t<InputIt>, value_type>
{
incr( distance( first, last ) );
super::insert( pos, first, last );
}
template<typename T, typename Alloc>
constexpr typename d_vector<T, Alloc>::iterator d_vector<T, Alloc>::insert( const_iterator pos, std::initializer_list<T> ilist )
{
incr( ilist.size() );
super::insert( pos, ilist );
}
template<typename T, typename Alloc>
template<typename ... Args>
requires std::is_constructible_v<T, Args ...>
constexpr typename d_vector<T, Alloc>::iterator d_vector<T, Alloc>::emplace( const_iterator pos, Args &&... args )
{
incr( 1 );
return super::emplace( pos, std::forward<Args>( args ) ... );
}
template<typename T, typename Alloc>
constexpr void d_vector<T, Alloc>::push_back( T const &value )
{
incr( 1 );
return super::push_back( value );
}
template<typename T, typename Alloc>
constexpr void d_vector<T, Alloc>::push_back( T &&value )
{
incr( 1 );
return super::push_back( std::move( value ) );
}
template<typename T, typename Alloc>
template<typename ... Args>
requires std::is_constructible_v<T, Args ...>
constexpr typename d_vector<T, Alloc>::reference d_vector<T, Alloc>::emplace_back( Args &&... args )
{
incr( 1 );
return super::emplace_back( std::forward<Args>( args ) ... );
}
#if defined(__cpp_lib_containers_ranges)
template<typename T, typename Alloc>
template<typename Range>
requires d_vector_range<Range, T>
constexpr void d_vector<T, Alloc>::assign_range( Range &&rg )
{
reCap( std::ranges::size( rg ) );
super::assign_range( rg );
}
template<typename T, typename Alloc>
template<typename Range>
requires d_vector_range<Range, T>
constexpr typename d_vector<T, Alloc>::iterator d_vector<T, Alloc>::insert_range( const_iterator pos, Range &&rg )
{
incr( std::ranges::size( rg ) );
return super::insert_range( pos, rg );
}
template<typename T, typename Alloc>
template<typename Range>
requires d_vector_range<Range, T>
constexpr void d_vector<T, Alloc>::append_range( Range &&rg )
{
incr( std::ranges::size( rg ) );
super::append_range( rg );
}
#endif
template<typename T, typename Alloc>
inline void d_vector<T, Alloc>::incr( size_t n )
{
reCap( super::size() + n );
}
template<typename T, typename Alloc>
inline void d_vector<T, Alloc>::reCap( size_t required )
{
if( size_t cap = super::capacity(); required > cap ) [[unlikely]]
complexReCap( required, cap );
}
template<typename T, typename Alloc>
__declspec(noinline)
void d_vector<T, Alloc>::complexReCap( size_t required, size_t cap )
{
using namespace std;
assert(required > cap);
// if capacity is zero increment it to one
cap += (size_t)!cap;
// make cap the same magnitude like required
cap <<= countl_zero( cap ) - countl_zero( required );
// required still larger than cap ?
// the branch is likely because cap is usually a power of two
if( required > cap ) [[likely]]
// yes: cap woudln't oveflow ?
if( (ptrdiff_t)cap >= 0 ) [[likely]]
// yes: double it
cap *= 2;
else
// no: throw bad_alloc
throw bad_alloc();
// reserve cap elements, which is >= required
try
{
// optimistically try to reseve new capacity
super::reserve( cap );
}
catch( bad_alloc const & )
{
// didn't work: try to reserve required capacity
super::reserve( required );
}
}
#else
template<typename T, typename Alloc = std::allocator<T>>
using d_vector = std::vector<T, Alloc>;
#endif