2901. Variants cannot properly support allocators

Section: 22.6.3 [variant.variant] Status: C++17 Submitter: United States Opened: 2017-02-03 Last modified: 2020-09-06

Priority: 0

View all other issues in [variant.variant].

View all issues with C++17 status.

Discussion:

Variants cannot properly support allocators, as any assignment of a subsequent value throws away the allocator used at construction. This is not an easy problem to solve, so variant would be better served dropping the illusion of allocator support for now, leaving open the possibility to provide proper support once the problems are fully understood.

Proposed change: Strike the 8 allocator aware constructor overloads from the class definition, and strike 20.7.2.1 [variant.ctor] p34/35. Strike clause 20.7.12 [variant.traits]. Strike the specialization of uses_allocator for variant in the <variant> header synopsis, 20.7.1 [variant.general].

[2017-02-28, Kona, Casey provides wording]

[2017-06-29 Moved to Tentatively Ready after 7 positive votes on c++std-lib.]

[2017-07 Toronto Moved to Immediate]

Proposed resolution:

This wording is relative to N4659.

1. Change 22.6.2 [variant.syn], header <variant> synopsis, as follows:

   […]
   //  [variant.traits], allocator-related traits
   template <class T, class Alloc> struct uses_allocator;
   template <class... Types, class Alloc> struct uses_allocator<variant<Types...>, Alloc>;
   

2. Change 22.6.3 [variant.variant], class template variant synopsis, as follows:

   […]
   // allocator-extended constructors
   template <class Alloc>
     variant(allocator_arg_t, const Alloc&);
   template <class Alloc>
     variant(allocator_arg_t, const Alloc&, const variant&);
   template <class Alloc>
     variant(allocator_arg_t, const Alloc&, variant&&);
   template <class Alloc, class T>
     variant(allocator_arg_t, const Alloc&, T&&);
   template <class Alloc, class T, class... Args>
     variant(allocator_arg_t, const Alloc&, in_place_type_t<T>, Args&&...);
   template <class Alloc, class T, class U, class... Args>
     variant(allocator_arg_t, const Alloc&, in_place_type_t<T>,
             initializer_list<U>, Args&&...);
   template <class Alloc, size_t I, class... Args>
     variant(allocator_arg_t, const Alloc&, in_place_index_t<I>, Args&&...);
   template <class Alloc, size_t I, class U, class... Args>
     variant(allocator_arg_t, const Alloc&, in_place_index_t<I>,
             initializer_list<U>, Args&&...);
   

3. Modify 22.6.3.2 [variant.ctor] as indicated:

   // allocator-extended constructors
   template <class Alloc>
     variant(allocator_arg_t, const Alloc& a);
   template <class Alloc>
     variant(allocator_arg_t, const Alloc& a, const variant& v);
   template <class Alloc>
     variant(allocator_arg_t, const Alloc& a, variant&& v);
   template <class Alloc, class T>
     variant(allocator_arg_t, const Alloc& a, T&& t);
   template <class Alloc, class T, class... Args>
     variant(allocator_arg_t, const Alloc& a, in_place_type_t<T>, Args&&... args);
   template <class Alloc, class T, class U, class... Args>
     variant(allocator_arg_t, const Alloc& a, in_place_type_t<T>,
             initializer_list<U> il, Args&&... args);
   template <class Alloc, size_t I, class... Args>
     variant(allocator_arg_t, const Alloc& a, in_place_index_t<I>, Args&&... args);
   template <class Alloc, size_t I, class U, class... Args>
     variant(allocator_arg_t, const Alloc& a, in_place_index_t<I>,
             initializer_list<U> il, Args&&... args);
   

   -34- Requires: Alloc shall meet the requirements for an Allocator (16.4.4.6 [allocator.requirements]).

   -35- Effects: Equivalent to the preceding constructors except that the contained value is constructed with uses-allocator construction (20.2.8.2 [allocator.uses.construction]).

4. Modify [variant.traits] as indicated:

   template <class... Types, class Alloc>
   struct uses_allocator<variant<Types...>, Alloc> : true_type { };
   

   -1- Requires: Alloc shall be an Allocator (16.4.4.6 [allocator.requirements]).

   -2- [Note: Specialization of this trait informs other library components that variant can be constructed with an allocator, even though it does not have a nested allocator_type. — end note]