Why assignment to std::function doesn't compile when it is a member of class X?

Question

The following code doesn't compile: ``` #include struct X { std::function _gen; }; int main() { X x; x._gen = [] { return X(); }; //this line is causing problem! } ``` I don't understand why assignment to `x._gen` is causing problem. Both gcc and clang are giving similar error messages. Could anyone please explain it? Compiler error messages GCC's error: ``` In file included from main.cpp:1:0: /usr/include/c++/4.8/functional: In instantiation of ‘std::function<_Res(_ArgTypes ...)>::_Requires::_CheckResult::_Invoke<_Functor>, _Res>, std::function<_Res(_ArgTypes ...)>&> std::function<_Res(_ArgTypes ...)>::operator=(_Functor&&) [with _Functor = main()::__lambda0; _Res = X; _ArgTypes = {}; std::function<_Res(_ArgTypes ...)>::_Requires::_CheckResult::_Invoke<_Functor>, _Res>, std::function<_Res(_ArgTypes ...)>&> = std::function&]…

Accepted Answer

This was PR60594, which got fixed in GCC 4.8.3. The comments on that bug point out why it is valid: although the standard requires template arguments for standard library templates to be a complete type (with some exceptions), `X()` is a complete type even if `X` is not. There are several members of `std::function` that do implicitly require `X` to be a complete type. The template constructor you're using is one of them: it requires the return type of your lambda to be implicitly convertible to `X`, but whether `X` is convertible to itself depends on whether `X` is a complete type: if it's incomplete, the compiler can't rule out the possibility that it is an uncopyable unmovable type. This requirement follows from: 20.9.11.2.1 function construct/copy/destroy [func.wrap.func.con] 8 Remarks: These constructors shall not participate in overload resolution unless `f` is Callable (20.9.11.2) for argument types `ArgTypes...` and return type `R`. 20.9.11.2 Class template function [func.wrap.func] 2 A callable object `f` of type `F` is Callable for argument types `ArgTypes` and return type `R` if the expression `INVOKE``(f, declval()..., R)`, considered as an unevaluated operand (Clause 5), is well formed (20.9.2). 20.9.2 Requirements [func.require] 2 Define `INVOKE``(f, t1, t2, ..., tN, R)` as `INVOKE``(f, t1, t2, ..., tN)` implicitly converted to `R`. Several other members of `std::function` also require `X` to be a complete type. You're only using that constructor after type `X` has already completed, though, so there's no problem: at that point, `X` certainly can be implicitly converted to `X`. The problem was that `std::function` was performing checks that depend on `X` being a complete type, in a context where the standard doesn't support performing such checks, and this did not account for the possibility that `X` would become a complete type after the instantiation of `std::function` had already completed.

Why assignment to std::function<X()> doesn't compile when it is a member of class X?

Solution

Problem