为什么这个 boost::variant::operator= 调用不能编译？

Question

为什么v = 42 不在这里编译？看起来编译器试图调用Foo的复制赋值运算符，为什么？我怎样才能让它编译？

#include <boost/variant.hpp>

struct Foo {
    Foo(Foo&&) { }
};

int main() {
    boost::variant<int, Foo> v;
    v = 42;
}

wandbox

错误信息是：

In file included from prog.cc:1:
In file included from /usr/local/boost-1.62.0/include/boost/variant.hpp:17:
/usr/local/boost-1.62.0/include/boost/variant/variant.hpp:619:21: error: object of type 'Foo' cannot be assigned because its copy assignment operator is implicitly deleted
        lhs_content = ::boost::detail::variant::move(*static_cast<T* >(rhs_storage_));
                    ^
/usr/local/boost-1.62.0/include/boost/variant/detail/visitation_impl.hpp:112:20: note: in instantiation of function template specialization 'boost::detail::variant::move_storage::internal_visit<Foo>' requested here
    return visitor.internal_visit(
                   ^
/usr/local/boost-1.62.0/include/boost/variant/detail/visitation_impl.hpp:154:13: note: in instantiation of function template specialization 'boost::detail::variant::visitation_impl_invoke_impl<boost::detail::variant::move_storage, void *, Foo>' requested here
    return (visitation_impl_invoke_impl)(
            ^
/usr/local/boost-1.62.0/include/boost/variant/detail/visitation_impl.hpp:240:11: note: in instantiation of function template specialization 'boost::detail::variant::visitation_impl_invoke<boost::detail::variant::move_storage, void *, Foo, boost::variant<int, Foo>::has_fallback_type_>' requested here
        , BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_CASE
          ^
/usr/local/boost-1.62.0/include/boost/preprocessor/repetition/repeat.hpp:29:26: note: expanded from macro 'BOOST_PP_REPEAT'
# define BOOST_PP_REPEAT BOOST_PP_CAT(BOOST_PP_REPEAT_, BOOST_PP_AUTO_REC(BOOST_PP_REPEAT_P, 4))
                         ^
/usr/local/boost-1.62.0/include/boost/preprocessor/cat.hpp:22:32: note: expanded from macro 'BOOST_PP_CAT'
#    define BOOST_PP_CAT(a, b) BOOST_PP_CAT_I(a, b)
                               ^
/usr/local/boost-1.62.0/include/boost/preprocessor/cat.hpp:29:34: note: expanded from macro 'BOOST_PP_CAT_I'
#    define BOOST_PP_CAT_I(a, b) a ## b
                                 ^
<scratch space>:128:1: note: expanded from here
BOOST_PP_REPEAT_1
^
/usr/local/boost-1.62.0/include/boost/variant/variant.hpp:2384:33: note: in instantiation of function template specialization 'boost::detail::variant::visitation_impl<mpl_::int_<0>, boost::detail::variant::visitation_impl_step<boost::mpl::l_iter<boost::mpl::l_item<mpl_::long_<2>, int, boost::mpl::l_item<mpl_::long_<1>, Foo, boost::mpl::l_end> > >, boost::mpl::l_iter<boost::mpl::l_end> >, boost::detail::variant::move_storage, void *, boost::variant<int, Foo>::has_fallback_type_>' requested here
        return detail::variant::visitation_impl(
                                ^
/usr/local/boost-1.62.0/include/boost/variant/variant.hpp:2398:16: note: in instantiation of function template specialization 'boost::variant<int, Foo>::internal_apply_visitor_impl<boost::detail::variant::move_storage, void *>' requested here
        return internal_apply_visitor_impl(
               ^
/usr/local/boost-1.62.0/include/boost/variant/variant.hpp:2125:19: note: in instantiation of function template specialization 'boost::variant<int, Foo>::internal_apply_visitor<boost::detail::variant::move_storage>' requested here
            this->internal_apply_visitor(visitor);
                  ^
/usr/local/boost-1.62.0/include/boost/variant/variant.hpp:2171:13: note: in instantiation of member function 'boost::variant<int, Foo>::variant_assign' requested here
            variant_assign( detail::variant::move(temp) );
            ^
/usr/local/boost-1.62.0/include/boost/variant/variant.hpp:2189:9: note: in instantiation of function template specialization 'boost::variant<int, Foo>::move_assign<int>' requested here
        move_assign( detail::variant::move(rhs) );
        ^
prog.cc:9:7: note: in instantiation of function template specialization 'boost::variant<int, Foo>::operator=<int>' requested here
    v = 42;
      ^
prog.cc:4:5: note: copy assignment operator is implicitly deleted because 'Foo' has a user-declared move constructor
    Foo(Foo&&) {}
    ^

Answer 1

我认为这行编译器警告说明：

prog.cc:4:5: note: copy assignment operator is implicitly deleted because 'Foo' has a user-declared move constructor

如果没有声明任何类型的用户声明的构造函数，编译器将只生成隐式声明的构造函数

这里有完整的描述on Default Constructors

当然可以只告诉它生成这个默认赋值，但不清楚你的实际代码，如果这样就可以了。具体来说，不清楚您为什么要使用自定义移动构造函数。

#include <boost/variant.hpp>

struct Foo {
    Foo(Foo&&) { }
    Foo& operator=(const Foo&) = default;
};

int main() {
    boost::variant<int, Foo> v;
    v = 42;
}

Answer 2

来自the docs：

Every bounded type must fulfill the requirements of the MoveAssignable concept.

并且 MoveAssignable 需要移动分配（尽管据我所知，这在文档中的任何地方都没有详细说明）。 Foo 不可移动赋值，因为用户提供的移动构造函数隐式删除了移动赋值运算符。因此，您不符合该运营商的要求。

这似乎是一个 QoI 问题。 operator=(int ) 没有理由需要 Foo::operator=(Foo )。我们可以在编译时确定哪种类型将成为新的参与类型（另一个要求），并且这是我们需要实例化的唯一类型 operator=。如果变体最初是 Foo，我们只想破坏原来的 Foo 并构造一个新的 int.

Answer 3

It seems the compiler is trying to call the copy assignment operator of Foo, why?

这只是令人困惑的措辞。一个移动赋值运算符（你也没有）就足够了。

至于为什么需要移动赋值运算符：boost::variant 的 operator= 是根据另一个 boost::variant 的赋值实现的。从您的 int 构建了一个 boost::variant<int, Foo>。 v 然后被移动分配给 boost::variant<int, Foo>。这需要考虑它被移动分配的可能性 Foo，即使那不可能发生。

您可以在编译器的错误消息和 variant.hpp:

中看到对此负责的 variant_assign 辅助方法

template <typename T>
void move_assign(T&& rhs)
{
    // If direct T-to-T move assignment is not possible...
    detail::variant::direct_mover<T> direct_move(rhs);
    if (this->apply_visitor(direct_move) == false)
    {
        // ...then convert rhs to variant and assign:
        //
        // While potentially inefficient, the following construction of a
        // variant allows T as any type convertible to one of the bounded
        // types without excessive code redundancy.
        //
        variant temp( detail::variant::move(rhs) );
        variant_assign( detail::variant::move(temp) );
    }
}

虽然那里有一个允许跳过临时变体的优化，但只有当变体已经包含 int 时才有可能，而且无论如何，它无法在编译时确定，所以它不会阻止了 variant_assign.

的实例化

为什么这个 boost::variant::operator= 调用不能编译？

Why doesn't this boost::variant::operator= call compile?

c++

boost

compiler-errors

variant

boost-variant