On Sun, Jul 26, 2015 at 11:13 PM, Glen Fernandes
It's up to you. It may be more intuitive having a separate policy, instead of turning GrowthPolicy into GrowthAndSizePolicy.
I'd like to avoid having too many policies. One could argue, that the chosen size type limits the maximum growth, thus it fits into the concept of the GrowthPolicy. I'll think on it.
It only enables someone to supply an allocator type without having to supply the rebound allocator type themselves.
e.g. The following code: template<class A> struct T { container1 c1; container2
c2; container3 c3; };
In this case, one should write: template <class A> struct T { template <class Y> using AY = typename std::allocator_traits<A>::rebind_alloc<Y>; container1 c1; // etc. }
.... looks cleaner than: template<class A> struct T { container1 c1; container2
c2; container3 c3; }; I know that some standard library vendors do this already: e.g. Using Dinkumware with Intel C++, the following will compile { std::vector
v; v.push_back(1); } Others do not: e.g. Using libc++ with Clang there is a static_assert "Allocator::value_type must be the same as value_type". It's up to you. Personally I think the former behavior is better, and if it isn't tolerable by the standard, it should be.
I think this version obscures intent and behaviour, and encourages sloppy use. It looks like the container uses allocator<X>, but really, it uses allocator<Y>, which is not nice. Or maybe it's just me being too strict. Thanks, Benedek