standardese | A nextgen Doxygen for C

It does not compile because a contexpr reference has to bind to an global variable object with static storage duration. Your reference is binding to a local variable so it is not constexpr and cannot be used to initialize another constexpr variable.

By removing the reference you initialize a 2nd array with the first one, which is a valid constexpr.

EDIT: I did not notice the language lawyer tag and do not have a copy of the C++ standard to quote, so feel free to answer if you do.

failbit should be set. It's done by sentry object, what ws constructs first thing.

[istream::sentry]/2
explicit sentry(basic_istream& is, bool noskipws = false);
Effects: If is.good() is false, calls is.setstate(failbit). Otherwise, ...

int* is a "derived declarator type"(not a standard term, but useful for reasoning about this). A functional style cast notation (which is what int(2) is) can only contain a "A simple-type-specifier or typename-specifier". A derived declarator type doesn't fall under either category.

You have to either:

• write it out in the form of a C-style cast:

The C standard does not define ordering for assignment of members within a structure when assigning a structure.

About assignment, C 2018 6.5.16.1 says only:

2 In simple assignment (=), the value of the right operand is converted to the type of the assignment expression and replaces the value stored in the object designated by the left operand.

3 If the value being stored in an object is read from another object that overlaps in any way the storage of the first object, then the overlap shall be exact and the two objects shall have qualified or unqualified versions of a compatible type; otherwise, the behavior is undefined.

Examining the standard for all mentions of “member”, “struct”, or “structure” does not reveal anything that would impose any chronological ordering on the members within the assignment. (There is not even an explicit definition of what the value of a structure is; we are left to presume it is effectively an ordered tuple of the value of its members, or perhaps, from “a structure is a type consisting of a sequence of members” in 6.7.2.1 6, that its value is a sequence of values of its members.)

A using declaration, while indeed a declaration as far as declarative regions are concerned, is not a function declaration. We can see it specified grammatically:

[dcl.dcl]

1 Declarations generally specify how names are to be interpreted. Declarations have the form

clang is correct here. Filed 87530.

The rule for return statements is [class.copy.elision]/3:

In the following copy-initialization contexts, a move operation might be used instead of a copy operation:

• If the expression in a return statement ([stmt.return]) is a (possibly parenthesized) id-expression that names an object with automatic storage duration declared in the body or parameter-declaration-clause of the innermost enclosing function or lambda-expression, or
• if the operand of a throw-expression is the name of a non-volatile automatic object (other than a function or catch-clause parameter) whose scope does not extend beyond the end of the innermost enclosing try-block (if there is one),

overload resolution to select the constructor for the copy is first performed as if the object were designated by an rvalue. If the first overload resolution fails or was not performed, or if the type of the first parameter of the selected constructor is not an rvalue reference to the object's type (possibly cv-qualified), overload resolution is performed again, considering the object as an lvalue. [ Note: This two-stage overload resolution must be performed regardless of whether copy elision will occur. It determines the constructor to be called if elision is not performed, and the selected constructor must be accessible even if the call is elided. — end note ]

Emphasis mine.

We meet the first bullet, we're returning an id-expression that names a non-volatile automatic object. So we perform overload resolution as if it were an rvalue. This overload resolution succeeds, there is a constructor that takes a Base&&. However, note the bolded part. The type of this parameter is not an rvalue reference to the object's type.

Hence, we try again consider the object as an lvalue. This overload resolution fails.

As a result, the program is ill-formed.

Structured binding exists to allow for multiple return values in a language that doesn't allow a function to resolve to more than one value (and thus does not disturb the C++ ABI). The means that whatever syntax is used, the compiler must ultimately store the actual return value. And therefore, that syntax needs a way to talk about exactly how you're going to store that value. Since C++ has some flexibility in how things are stored (as references or as values), the structured binding syntax needs to offer the same flexibility.

Hence the auto & or auto&& or auto choice applying to the primary value rather than the subobjects.

Second, we don't want to impact performance with this feature. Which means that the names introduced will never be copies of the subobjects of the main object. They must be either references or the actual subobjects themselves. That way, people aren't concerned about the performance impact of using structured binding; it is pure syntactic sugar.

Third, the system is designed to handle both user-defined objects and arrays/structs with all public members. In the case of user-defined objects, the "name is bound to" a genuine language reference, the result of calling get(value). If you store a const auto& for the object, then value will be a const& to that object, and get will likely return a const&.

The term "forwarding reference" is described at [temp.deduct.call/3](from C++17 draft n4659):

A forwarding reference is an rvalue reference to a cv-unqualified template parameter that does not represent a template parameter of a class template (during class template argument deduction).

In your example Container is not a template parameter, it is a type you comprised from the template parameters T and Container. In order for the reference to be truly forwarding, you can use T&& only. While Conatiner is a template parameter, you can't have a reference to a template (the above paragraphs even mentions it explicitly). The type Container is not the same as the template Container. It's an instantiated class.¹

While you can use SFINAE to obtain a forwarding reference that can be bound only to the container type, I personally feel you're better off just overloading the function.

The reason that the code snippet in question compiles is due to non-standard conforming behavior from Visual Studio (I'm currently using VS2017.3 Preview, which compiles the code without errors even with the /permissive- flag). Below is the error emitted by GCC and Clang: