DCL | Construction Learning for Fine-grained Image Recognition | Machine Learning library

The intent is to disallow redeclaring structured bindings as references. See CWG 2313.

GCC is wrong. It assumes that a is not yet in scope in the default argument, although generally the point of declaration is immediately after the declarator before the initializer and none of the exceptions apply here. [basic.scope.pdecl]/1

An older bug report for this is here.

Note however, that the bug report has equivalent code to yours, but claims it should be ill-formed. That is because it was written before CWG 2082 which allowed the use of a parameter in an unevaluated context in the default argument.

Related question regarding this GCC bug here.

In C, there are no references, and you have to type struct, and you have to take care of initialization.

I find this a particularly good use case for call scan, regex isn't nearly as efficient. Here I use call scan to find the "word boundary" of the (always single) letter, then grab it plus whatever's before the next letter (or end-of-word).

GCC and Clang report that S is trivially copyable in C++11 through C++23 standard modes. MSVC reports that S is not trivially copyable in C++14 through C++20 standard modes.

N3337 (~ C++11) and N4140 (~ C++14) say:

A trivially copyable class is a class that:

• has no non-trivial copy constructors,
• has no non-trivial move constructors,
• has no non-trivial copy assignment operators,
• has no non-trivial move assignment operators, and
• has a trivial destructor.

By this definition, S is trivially copyable.

N4659 (~ C++17) says:

A trivially copyable class is a class:

• where each copy constructor, move constructor, copy assignment operator, and move assignment operator is either deleted or trivial,
• that has at least one non-deleted copy constructor, move constructor, copy assignment operator, or move assignment operator, and
• that has a trivial, non-deleted destructor

By this definition, S is not trivially copyable.

N4860 (~ C++20) says:

A trivially copyable class is a class:

• that has at least one eligible copy constructor, move constructor, copy assignment operator, or move assignment operator,
• where each eligible copy constructor, move constructor, copy assignment operator, and move assignment operator is trivial, and
• that has a trivial, non-deleted destructor.

By this definition, S is not trivially copyable.

Thus, as published, S was trivally copyable in C++11 and C++14, but not in C++17 and C++20.

The change was adopted from DR 1734 in February 2016. Implementors generally treat DRs as though they apply to all prior language standards by convention. Thus, by the published standard for C++11 and C++14, S was trivially copyable, and by convention, newer compiler versions might choose to treat S as not trivially copyable in C++11 and C++14 modes. Thus, all compilers could be said to be correct for C++11 and C++14.

For C++17 and beyond, S is unambiguously not trivially copyable so GCC and Clang are incorrect. This is GCC bug #96288 and LLVM bug #39050

[basic.start.main]/4:

If std​::​exit is called to end a program during the destruction of an object with static or thread storage duration, the program has undefined behavior.

This program is well-formed and prints 1, as seen. Because S is defined identically in both translation units with external linkage, it is as if there is one definition of S ([basic.def.odr]/14) and thus only one enumeration type is defined. (In practice it is mangled based on the name S or S::x.)

This is just the same phenomenon as static local variables and lambdas being shared among the definitions of an inline function:

The standard doesn't allow it:

For each entity captured by copy, an unnamed non-static data member is declared in the closure type.

If it's "unnamed", then you can't name it. There's specific language that causes the name of a captured entity to be transformed into a this-based expression, but that's it.

So you can take an explicit this parameter, and names of captured entities will automatically use that. But you can't access those variables through the explicit parameter.

The only reason to explicitly take this in a lambda is to use the interfaces the standard provides: calling the lambda. AKA: recursively calling the lambda without naming the lambda.

(Several questions in the same questions: I will answer one)

Is the following statement correct?

• An uninitialized reference is considered zero-initialized.

No. There is no such thing as an uninitialized reference, as it would need to refer to a variable or object, as opposed to a (reference type) parameter or a (reference type) return type, in which context initialization do not apply; as per [dcl.init.ref]/1 and /3:

/1 A variable whose declared type is “reference to T” ([dcl.ref]) shall be initialized.

/3 The initializer can be omitted for a reference only in a parameter declaration ([dcl.fct]), in the declaration of a function return type, in the declaration of a class member within its class definition ([class.mem]), and where the extern specifier is explicitly used.

Regarding the quoted [dcl.init.general]/6:

To zero-initialize an object or reference of type T means:

• [...]
• [...] if T is a reference type, no initialization is performed.

it refers to the cases where other parts of the standard governs that zero-initialization applies (and what is the effect of it for different entities); for initialization of a reference, particularly consider static initialization, as governed per [basic.start.static]/2:

[...] If constant initialization is not performed, a variable with static storage duration ([basic.stc.static]) or thread storage duration ([basic.stc.thread]) is zero-initialized ([dcl.init]). Together, zero-initialization and constant initialization are called static initialization; all other initialization is dynamic initialization. All static initialization strongly happens before ([intro.races]) any dynamic initialization.

Such that static initialization of a reference type variable (which is not constant-initialized) will pertain solely of dynamic initialization, as the effect of the zero initialization of first step of static initialization is no initialization.