This page is a snapshot from the LWG issues list, see the Library Active Issues List for more information and the meaning of WP status.

3585. Variant converting assignment with immovable alternative

Section: 22.6.3.4 [variant.assign] Status: WP Submitter: Barry Revzin Opened: 2021-09-01 Last modified: 2021-10-14

Priority: Not Prioritized

View all other issues in [variant.assign].

View all issues with WP status.

Discussion:

Example originally from StackOverflow but with a more reasonable example from Tim Song:

#include <variant>
#include <string>

struct A {
  A() = default;
  A(A&&) = delete;
};

int main() {
  std::variant<A, std::string> v;
  v = "hello";
}

There is implementation divergence here: libstdc++ rejects, libc++ and msvc accept.

22.6.3.4 [variant.assign] bullet (13.3) says that if we're changing the alternative in assignment and it is not the case that the converting construction won't throw (as in the above), then "Otherwise, equivalent to operator=(variant(std::forward<T>(t)))." That is, we defer to move assignment.

variant<A, string> isn't move-assignable (because A isn't move constructible). Per the wording in the standard, we have to reject this. libstdc++ follows the wording of the standard.

But we don't actually have to do a full move assignment here, since we know the situation we're in is changing the alternative, so the fact that A isn't move-assignable shouldn't matter. libc++ and msvc instead do something more direct, allowing the above program.

[2021-09-20; Reflector poll]

Set status to Tentatively Ready after seven votes in favour during reflector poll.

[2021-10-14 Approved at October 2021 virtual plenary. Status changed: Voting → WP.]

Proposed resolution:

This wording is relative to N4892.

1. Modify 22.6.3.4 [variant.assign] as indicated:

   [Drafting note: This should cover the case that we want to cover: that if construction of T_j from T throws, we haven't yet changed any state in the variant.]

   template<class T> constexpr variant& operator=(T&& t) noexcept(see below);
   

   -11- Let T_j be a type that is determined as follows: build an imaginary function FUN(T_i) for each alternative type T_i for which T_i x[] = {std::forward<T>(t)}; is well-formed for some invented variable x. The overload FUN(T_j) selected by overload resolution for the expression FUN(std::forward<T>(t)) defines the alternative T_j which is the type of the contained value after assignment.

   -12- Constraints: […]

   -13- Effects:

   1. (13.1) — If *this holds a T_j, assigns std::forward<T>(t) to the value contained in *this.

   2. (13.2) — Otherwise, if is_nothrow_constructible_v<T_j, T> || !is_nothrow_move_constructible_v<T_j> is true, equivalent to emplace<j>(std::forward<T>(t)).

   3. (13.3) — Otherwise, equivalent to operator=(variant(std::forward<T>(t)))emplace<j>(T_j(std::forward<T>(t))).