[C++] 람다 표준

부족한 실력이나마 번역을 좀 해보았는데.. 지적이나 조언 감사히 받습니다.

8.1.5 Lambda expressions
: 람다 표현식

Lambda expressions provide a concise way to create simple function objects. 
: 람다 표현식은 심플한 함수객체를 만드는 손쉬운 방법을 제공한다.

[ Example:

#include

#include

void abssort(float* x, unsigned N)
{
ㅤstd::sort(x, x + N, [](float a, float b) { return ㅤstd::abs(a) < std::abs(b); });
}

— end example ]

2 A lambda-expression is a prvalue whose result object is called the closure object. 
: 람다 표현식은 클로저 객체를 부른 결과물로, 순수한 오른값을 반환한다.

A lambda-expression shall not appear in an unevaluated operand (Clause 8), in a template-argument, in an alias-declaration, in a typedef declaration, or in the declaration of a function or function template outside its function body and default arguments. 
: 람다식은 평가되지 않은 피연산자와, 템플릿인자와, 익명범위?(alias-declaration)와, typedef 선언에서나, 함수의 선언이나, 함수 템플릿 몸체나, 디폴트매개변수에서는 나타날 수 없다.

[ Note: The intention is to prevent lambdas from appearing in a signature. — end note ] 
: 그 의도는 람다가 시그너처에서 나타나는 것을 예방하기 위함이다.

[ Note: A closure object behaves like a function object (23.14). — end note ]
: 클로저 객체는 함수객체와 비슷하게 작동한다.

3 In the decl-specifier-seq of the lambda-declarator, each decl-specifier shall either be mutable or constexpr.
: 람다 선언자의 선언부에서 각각의 선언지정자는 mutable과 constexpr을 허용한다.

4 If a lambda-expression does not include a lambda-declarator, it is as if the lambda-declarator were (). 
: 람다식이 람다 선언자를 포함하지 않는다면, 그건 람다 선언자가 ()인것과 같다.

The lambda return type is auto, which is replaced by the type specified by the trailing-return-type if provided and/or deduced from return statements as described in 10.1.7.4. 
: 람다의 리턴타입은 auto이다.
만약 10.1.7.4에서 설명하는 것처럼 반환문에서 타입이 제공되거나 추론된다면 trailing-return-type(후행반환타입)에 의해 지정된 타입으로 교체된다.

[ Example:

auto x1 = [](int i){ return i; };
// OK: 리턴타입이 int다.
auto x2 = []{ return { 1, 2 }; };
// error: 중괄호초기치로 추론한다.

int j;

auto x3 = [\]()->auto&& { return j; };
// OK: 리턴타입이 int&이다.

— end example ]

8.1.5.1 Closure types
: 클로저 타입

1 The type of a lambda-expression (which is also the type of the closure object) is a unique, unnamed non-union class type, called the closure type, whose properties are described below.
: 람다식의 타입은 '유일하며'(unique),
이름이 없고 뭔가에 속해있지도 않은 클래스 타입이며,
클로저 타입이라고도 부르는데, 이에 관한 속성들은 아래에서 설명한다.

2 The closure type is declared in the smallest block scope, class scope, or namespace scope that contains the corresponding lambda-expression. 
: 클로저 타입은 부합하는 람다식을 포함하는 가장 작은 블럭 스코프, 클래스 스코프, 이름공간 스코프에서 선언된다.

[ Note: This determines the set of namespaces and classes associated with the closure type (6.4.2). 
: 이것은 이름공간의 집합과 클로저타입과 관계된 클래스들을 알아낸다.

The parameter types of a lambda-declarator do not affect these associated namespaces and classes. — end note ]
: 람다 선언자의 파라미터 타입들은 관련된 네임스페이스나 클래스들에 대해서 아무 영향도 주지 않는다.

The closure type is not an aggregate type (11.6.1). 
: 클로저 타입은 aggregate 타입이 아니다.(뭔소린지 모르겠음)

An implementation may define the closure type differently from what is described below provided this does not alter the observable behavior of the program other than by changing:
: 구현은 다음 사항들을 변경하는 것 이외에 드러나는 동작을 변경하지 않는다면 아래에 설명 된 것과 다른 방식으로 클로저 타입을 정의해도 된다.

(2.1) — the size and/or alignment of the closure type,
클로저 타입의 사이즈나 할당량

(2.2) — whether the closure type is trivially copyable (Clause 12),
클로저 타입이 복사 가능한지 아닌지,

(2.3) — whether the closure type is a standard-layout class Clause 12), or
클로저타입이 표준 레이아웃 클래스인지 아닌지,

(2.4) — whether the closure type is a POD class (Clause 12).
클로저타입이 POD 클래스인지 아닌지.

An implementation shall not add members of rvalue reference type to the closure type.
구현은 클로저 타입에 오른값 참조 타입의 멤버들을 추가하는 것을 허용하지 않는다.

3 The closure type for a non-generic lambda-expression has a public inline function call operator (16.5.4)
: 비-제너릭 람다식의 클로저 타입은 공개된 인라인 함수 연산자(함수객체)를 가진다.

whose parameters and return type are described by the lambda-expression’s parameter-declaration-clause and trailing-return-type respectively. 
: 파라미터와 리턴타입은 각각 람다식의 매개 변수 선언절 및 후행 리턴타입(trailing-return-type)에 의해 설명된다.

For a generic lambda, the closure type has a public inline function call operator member template (17.5.2) whose template parameter-list consists of one invented type template￾parameter for each occurrence of auto in the lambda’s parameter-declaration-clause, in order of appearance.
: 제너릭 람다의 경우, 클로저 타입은 public 인라인 함수 호출 연산자 멤버 템플릿(17.5.2)을 가지며, 그 템플릿 파라미터리스트는 람다 파라미터 선언 부에서 나타난 순서대로, 각 자동 발생에 대한 하나의 급조된(invented) 타입 템플릿 파라미터로 구성된다.

The invented type template-parameter is a parameter pack if the corresponding parameter-declaration declares a function parameter pack (11.3.5). 
: 급조된 타입 템플릿 파라미터는 만약 해당되는 파라미터 선언이 함수 파라미터 팩을 선언한다면, 하나의 파라미터 팩이 된다.

The return type and function parameters of the function call operator template are derived from the lambda-expression’s trailing-return-type and parameter-declaration-clause by replacing each occurrence of auto in the decl-specifiers of the parameter-declaration-clause with the name of the corresponding invented template-parameter. 
: 함수 호출 연산자 템플릿의 리턴타입과 함수 파라미터는 람다식의 trailing-return-type과 파라미터 선언절로부터 유도된다.
파라미터 선언절의 decl 지정자에서 auto의 발생을 각각 급조된 템플릿 파라미터에 해당하는 이름으로 교체해서 말이다.

[Example:

auto glambda = [](auto a, auto&& b) { return a < b; };

bool b = glambda(3, 3.14); // OK

auto vglambda = [](auto printer)
{
    return [=](auto&& ... ts)
    {
    // OK: ts는 함수 파라미터 팩이다.

        printer(std::forward<decltype(ts)>(ts)...);

        return [=]() { printer(ts ...); };
    };
};

auto p = vglambda( [](auto v1, auto v2, auto v3)

{ std::cout << v1 << v2 << v3; } );

auto q = p(1, ’a’, 3.14); // OK: 1a3.14 출력

q(); // OK: 1a3.14 출력.

— end example ]

4 The function call operator or operator template is declared const (12.2.2) if and only if the lambda-expression’s parameter-declaration-clause is not followed by mutable. 
: 함수객체나 연산자템플릿은 오직 람다식의 파라미터 선언절에 mutable이 따라오지 않는 경우에만 const로 선언된다.

It is neither virtual nor declared volatile.
: virtual도 아니고 volatile도 선언되지도 않는다.

Any noexcept-specifier specified on a lambda-expression applies to the corresponding function call operator or operator template. 
: 람다식에 지정된 모든 noexcept 지정자는 해당되는 함수호출 연산자나 연산자 템플릿에 적용된다.

An attribute-specifier-seq in a lambda-declarator appertains to the type of the corresponding function call operator or operator template. 
: 람다-선언자에 있는 attribute 지정자 시퀀스는 해당되는 함수호출 연산자나 연산자 템플릿의 타입에 속한다.

The function call operator or any given operator template specialization is a constexpr function if either the corresponding lambda-expression’s parameter-declaration￾clause is followed by constexpr, or it satisfies the requirements for a constexpr function (10.1.5). 
: 함수호출 연산자나 어떤 특정 연산자 템플릿 특수화는 람다식의 파라미터 선언절에 constexpr이 따라오거나, constexpr 함수의 요구사항을 만족할 경우, constexpr 함수가 된다.

[ Note: Names referenced in the lambda-declarator are looked up in the context in which the lambda-expression appears. — end note ] 
: Note: 람다식 선언자에게 참조된 이름들은 람다식이 나타난 컨텍스트에서 룩업된다.

[Example: 

auto ID = [](auto a) { return a; };

static_assert(ID(3) == 3); // OK

struct NonLiteral
{
    NonLiteral(int n) : n(n) { }
    int n;
};

static_assert(ID(NonLiteral{3}).n == 3); // ill-formed

— end example ]

5 [Example:

auto monoid = [](auto v)
{
    return [=] { return v; };
};

auto add = [](auto m1) constexpr
{
    auto ret = m1();
    return [=](auto m2) mutable
    {
        auto m1val = m1();
        auto plus = [=](auto m2val) mutable constexpr
        {
            return m1val += m2val;
        };
        ret = plus(m2());
        return monoid(ret);
    };
};

constexpr auto zero = monoid(0);

constexpr auto one = monoid(1);

static_assert(add(one)(zero)() == one());
// OK

// Since two below is not declared constexpr, an evaluation of its constexpr member function call operator
: 아래 두 개는 constexpr로 선언되어 있지 않으나, constexpr 멤버 함수 호출 연산자로 평가.

// cannot perform an lvalue-to-rvalue conversion on one of its subobjects (that represents its capture)
: 해당 캡쳐를 나타내는 서브객체 중 하나에서 왼값에서 오른값으로의 변환은 수행할 수 없다.

// in a constant expression.
: 상수 표현식에서

auto two = monoid(2);

assert(two() == 2);
// OK, 상수 표현식이 아니다.

static_assert(add(one)(one)() == two());
// 잘못된 포맷: two()는 상수 표현식이 아님

static_assert(add(one)(one)() == monoid(2)()); // OK

— end example ]

6 The closure type for a non-generic lambda-expression with no lambda-capture has a conversion function to pointer to function with C++ language linkage (10.5) having the same parameter and return types as the closure type’s function call operator. 
: 캡쳐가 없는 비-제너릭 람다 표현식의 클로저 타입은 클로저 타입의 함수호출연산자와 같은 파라미터와 리턴타입의 C++언어 연결(10.5) 함수에 대한 포인터, 변환(conversion) 함수를 가진다.

The conversion is to “pointer to noexcept function” if the function call operator has a non-throwing exception specification. 
: 그 함수호출 연산자가 예외를 던지지 않는다는 지정자를 갖고 있다면, 그 변환은 "noexcept 함수에 대한 포인터"가 된다.

The value returned by this conversion function is the address of a function F that, when invoked, has the same effect as invoking the closure type’s function call operator. 
: 이 변환 함수에 의해 반환되는 값은 함수 F의 주소이고, 호출될 때마다 클로저타입의 함수호출연산자를 호출하는 것과 동일한 효과를 낸다.

F is a constexpr function if the function call operator is a constexpr function.
: 그 함수호출 연산자가 constexpr 함수라면, F도 constexpr 함수가 된다.

For a generic lambda with no lambda-capture, the closure type has a conversion function template to pointer to function.
: 캡쳐 없는 제너릭 람다의 경우, 그 클로저타입은 그 함수에 대한 포인터, 변환함수 템플릿을 가진다.

The conversion function template has the same invented template-parameter-list, and the pointer to function has the same parameter types, as the function call operator template. 
: 변환함수 템플릿은 동일한 급조된-템플릿파라미터-리스트를 가진다.
그리고 함수에 대한 포인터는 그 함수호출연산자 템플릿과 같이, 동일한 파라미터 타입을 가진다.

The return type of the pointer to function shall behave as if it were a decltype-specifier denoting the return type of the corresponding function call operator template specialization.
: 함수에 대한 포인터의 리턴 타입은, decltype 지정자가 해당되는 함수호출연산자 템플릿 특수화의 리턴타입을 나타내는 것처럼 행동한다.

7 [ Note: If the generic lambda has no trailing-return-type or the trailing-return-type contains a placeholder type, return type deduction of the corresponding function call operator template specialization has to be done.
: 제너릭 람다가 trailing-return-type을 갖고있지 않거나, 그 trailing-return-type이 placeholder 타입을 포함한다면, 해당되는 함수호출연산자 템플릿 특수화의 리턴타입 연역은 수행되어야만 한다.

The corresponding specialization is that instantiation of the function call operator template with the same template arguments as those deduced for the conversion function template. 
: 해당되는 특수화는 변환함수 템플릿에 추론된 것과 동일한 템플릿 연산자를 가지는 함수호출연산자 템플릿의 인스턴트화이다.

Consider the following:
->이런걸 고려해보자

auto glambda = [](auto a) { return a; };

int (*fp)(int) = glambda;

The behavior of the conversion function of glambda above is like that of the following conversion function:
->glambda의 변환함수가 하는 행동은 아래 변환함수가 하는 것과 같다.

struct Closure {
    template auto operator()(T t) const
    { ... }

    template static auto lambda_call_operator_invoker(T a)
    {
    // forwards execution to operator()(a) and therefore has
    // the same return type deduced
    ...
    }

    template using fptr_t =    decltype(lambda_call_operator_invoker(declval())) (*)(T);

    template operator fptr_t() const
    {
        return &lambda_call_operator_invoker;
    }
};

— end note ]

[Example:

void f1(int (*)(int)) { }

void f2(char (*)(int)) { }

void g(int (*)(int)) { } // #1

void g(char (*)(char)) { } // #2

void h(int (*)(int)) { } // #3

void h(char (*)(int)) { } // #4

auto glambda = [](auto a) { return a; };

f1(glambda); // OK

f2(glambda); // error: ID는 전환할 수 없다.

g(glambda); // error: 모호함

h(glambda); // OK: calls #3 since it is convertible from ID

int& (fpi)(int) = [](auto* a) -> auto& { return *a; }; // OK

— end example ]

8 The value returned by any given specialization of this conversion function template is the address of a function F that, when invoked, has the same effect as invoking the generic lambda’s corresponding function call operator template specialization. 
: 이 변환함수 템플릿의 어떤 특수화에 의해 리턴되는 값은 함수 F의 주소이다.
그리고 호출될 때마다 그 제너릭 람다에 해당하는 함수호출연산자 템플릿 특수화를 호출하는 것과 같은 효과를 낸다.

F is a constexpr function if the corresponding specialization is a constexpr function. 
: 해당하는 특수화가 constexpr 함수라면 F는 constexpr 함수가 된다.

[ Note: This will result in the implicit instantiation of the generic lambda’s body.
: 이건 제너릭 람다 몸체의 암시적인 인스턴스화를 초래한다.
The instantiated generic lambda’s return type and parameter types shall match the return type and parameter types of the pointer to function. — end note ] 
: 인스턴스화된 제너릭 람다의 리턴타입과 파라미터타입은 그 함수에 대한 포인터의 리턴타입과 파라미터타입에 매치된다.

[Example:

auto GL = [](auto a) { std::cout << a; return a; };

int (*GL_int)(int) = GL;
// OK: 변환함수템플릿을 통함.

GL_int(3);
// OK: GL(3)와 같음

— end example ]

9 The conversion function or conversion function template is public, constexpr, non-virtual, non-explicit, const, and has a non-throwing exception specification (18.4). 
: 변환함수나 변환함수 템플릿은 public이며, constexpr이며, non-virtual이며, 암시적이며, const하며, noexcept 지정자를 가진다.

[ Example:

auto Fwd = [](int (*fp)(int), auto a) { return fp(a); };

auto C = [](auto a) { return a; };

static_assert(Fwd(C,3) == 3); // OK

// No specialization of the function call operator template can be constexpr (due to the local static).
-> 함수호출연산자 템플릿의 특수화는 local static 때문에 constexpr이 될 수 없다.

auto NC = [](auto a) { static int s; return a; };

static_assert(Fwd(NC,3) == 3); // ill-formed

— end example ]

10 The lambda-expression’s compound-statement yields the function-body (11.4) of the function call operator, but for purposes of name lookup (6.4), determining the type and value of this (12.2.2.1) and transforming id￾expressions referring to non-static class members into class member access expressions using (*this) (12.2.2), the compound-statement is considered in the context of the lambda-expression. 
: 람다식의 복합구문은 그 함수호출 연산자의 함수몸체를 내어준다.
하지만 이름 룩업을 목적으로 할 경우, 이것의 타입과 값을 결정하고, 비-정적 클래스 멤버를 참조하는 id? 표현식을 *this를 사용하는 클래스 멤버 액세스 표현식으로 변환한다.
그리고 그 복합구문은 그 람다식의 컨텍스트 내에서 고려된다.

[Example:

struct S1
{
    int x, y;
    int operator()(int);

    void f()
    {
        [=]()->int
        {
            return operator()(this->x + y);
            // equivalent to S1::operator()(this->x + (this).y)
            // this has type S1
        };
    }
};

— end example ] 

Further, a variable func is implicitly defined at the beginning of the compound-statement of the lambda-expression, with semantics as described in 11.4.1.
: 더 나아가서 변수 __func__는 함시적으로 람다식의 복합구문 시작부분에서 정의되었다.
11.4.1에서 설명한 것과 같은 의미로.

11 The closure type associated with a lambda-expression has no default constructor and a deleted copy assignment operator. 
: 람다식과 관련된 클로저타입은 그 어떤 디폴트생성자나 삭제된 복사할당연산자도 갖고 있지 않다.

It has a defaulted copy constructor and a defaulted move constructor (15.8). 
: 디폴트 복사생성자와 디폴트 이동생성자를 가진다.

[ Note: These special member functions are implicitly defined as usual, and might therefore be defined as deleted. — end note ]
: 이 특수한 멤버함수는 암시적으로 그냥 정의되므로, 삭제된 것과 같이 정의된다.

12 The closure type associated with a lambda-expression has an implicitly-declared destructor (15.4).
: 람다식과 관계된 클로저타입은 암시적으로 선언된 소멸자를 갖는다.

13 A member of a closure type shall not be explicitly instantiated (17.7.2), explicitly specialized (17.7.3), or named in a friend declaration (14.3).
: 클로저타입의 멤버는 명시적으로 인스턴스화되지 않고, 명시적으로 특수화되지 않고, friend로 선언되지 못한다.

8.1.5.2 Captures ->캡쳐

1 The body of a lambda-expression may refer to variables with automatic storage duration and the *this object (if any) of enclosing block scopes by capturing those entities, as described below.
: 람다식의 몸체는 자동저장 기간의 변수와, 아래에서 설명하는 것과 같이, 엔티티들을 캡쳐해서 에워싼 블럭 스코프의 *this 객체(있다면)를 참조할 수도 있다.

2 If a lambda-capture includes a capture-default that is &, no identifier in a simple-capture of that lambda-capture shall be preceded by &. 
: 캡쳐에서 캡쳐디폴트 &를 포함한다면, 그 캡쳐의 심플캡쳐에서 그냥 식별자는 &보다 앞에 올수 없다.

If a lambda-capture includes a capture-default that is =, each simple-capture of that lambda-capture shall be of the form “& identifier” or “* this”. 
: 만약 캡쳐가 디폴트캡쳐 =를 포함한다면, 그 캡쳐의 심플캡쳐는 각각 &식별자나 *this의 형식을 가져야만 한다.

[ Note: The form [&,this] is redundant but accepted for compatibility with ISO C++ 2014. — end note ] Ignoring appearances in initializers of init-captures, an identifier or this shall not appear more than once in a lambda-capture. 
: [&,this] 같은 형식은 별로 쓸데는 없지만 ISO C++2014와의 호환성을 위해서 허용된다.
초기화캡쳐의 이니셜라이저에서 나타나는 것을 무시하면, 식별자나 this는 람다캡쳐에서 한번 이상 나타날 수 없다.

[Example:

struct S2 { void f(int i); };

void S2::f(int i)
{
    [&, i]{ }; // OK

    [&, &i]{ }; // error: i preceded by & when & is the default

    [=, *this]{ }; // OK

    [=, this]{ }; // error: this when = is the default

    [i, i]{ }; // error: i repeated

    [this, *this]{ }; // error: this appears twice
}

— end example ]

3 A lambda-expression whose smallest enclosing scope is a block scope (6.3.3) is a local lambda expression;
any other lambda-expression shall not have a capture-default or simple-capture in its lambda-introducer. 
: 가장 가까운 바깥 스코프가 블럭 스코프인 람다식은 로컬 람다식이다.

The reaching scope of a local lambda expression is the set of enclosing scopes up to and including the innermost enclosing function and its parameters. 
: 로컬 람다식의 도달 범위(스코프)는 가장 안쪽에서 둘러싸는 함수와 그 파라미터를 포함하는 주변스코프의 집합이다.

[ Note: This reaching scope includes any intervening lambda-expressions. — end note ]
: 이 도달범위에는 끼어있는 람다식들이 포함된다.

4 The identifier in a simple-capture is looked up using the usual rules for unqualified name lookup (6.4.1);
each such lookup shall find an entity. 
: 심플캡쳐에서의 식별자는 자격없는 이름 룩업 때문에 통상적인 규칙을 사용해서 룩업을 한다.

An entity that is designated by a simple-capture is said to be explicitly captured, and shall be this (when the simple-capture is “this” or “ this”) or a variable with automatic storage duration declared in the reaching scope of the local lambda expression.
: 심플캡쳐에 의해 지정된 엔티티는 명시적으로 캡쳐가 된다. 그리고 *this나 그 로컬람다식의 도달범위 내에서 자동저장기간으로 선언된 변수도 쓸 수가 있다.

5 If an identifier in a simple-capture appears as the declarator-id of a parameter of the lambda-declarator’s parameter-declaration-clause, the program is ill-formed. 
: 심플캡쳐에서의 식별자가 그 람다선언자의 파라미터와 이름이 같다면, 그건 잘못된 형석이다.

[ Example:

void f()
{
ㅤint x = 0;

ㅤauto g = [x](int x) { return 0; }
ㅤ// error: parameter and simple-capture have the same name
}

— end example ]

6 An init-capture behaves as if it declares and explicitly captures a variable of the form “auto init-capture ;”
whose declarative region is the lambda-expression’s compound-statement, except that:
: 초기화캡쳐는 그것이 선언되고 "자동 초기화 캡쳐" 형식의 변수를 명시적으로 캡쳐하는 것처럼 수행된다. 이게 선언된 구역은 람다식의 복합구문이다.
이런 것들은 제외된다:

(6.1) — if the capture is by copy (see below), the non-static data member declared for the capture and the variable are treated as two different ways of referring to the same object, which has the lifetime of the non-static data member, and no additional copy and destruction is performed, and
: 캡쳐가 복사된다면, 비-정적 데이터 멤버가 캡쳐를 위해 선언되고, 변수가 같은 객체를 참조하는 것에 두가지 방법으로 처리가 된다.
그래서 그것은 비-정적 데이터 멤버의 생명주기를 가지고, 추가적인 복사나 소멸은 수행되지 않는다.
그리고?

(6.2) — if the capture is by reference, the variable’s lifetime ends when the closure object’s lifetime ends.
: 만약 캡쳐가 레퍼런스라면 그 변수의 생명주기는 클로저 객체의 생명주기 종료시에 종료된다.

[ Note: This enables an init-capture like “x = std::move(x)”; the second “x” must bind to a declaration in the surrounding context. — end note ] 
: 이건 초기화캡쳐를 “x = std::move(x)”처럼 쓰는 걸 가능케 한다.
두번째로 "x"는 주변 컨텍스트에서 선언된 것을 바인딩해야만 한다.

[Example:

int x = 4;

auto y = [&r = x, x = x+1]()->int
{
    r += 2;
    return x+2;
}(); // Updates ::x to 6, and initializes y to 7.

auto z = [a = 42](int a) { return 1; }
// error: parameter and local variable have the same name

— end example ]

7 A lambda-expression with an associated capture-default that does not explicitly capture *this or a variable with automatic storage duration (this excludes any id-expression that has been found to refer to an init￾capture’s associated non-static data member), is said to implicitly capture the entity (i.e., *this or a variable)
: 캡쳐디폴트와 관계된 람다식은 명시적으로 *this나 자동저장기간 변수를 캡쳐하지 않는다.
(이건 초기화캡쳐와 관계된 비-정적 데이터 멤버를 참조하는 것에서 발견된 모든  id 표현식을 제외한다.)
그리고 암시적으로 엔티티를 캡쳐한다.
(*this나 변수)

if the compound-statement:
: 복합구문이라면 ->

(7.1) — odr-uses (6.2) the entity (in the case of a variable),

(7.2) — odr-uses (6.2) this (in the case of the object designated by *this), or

(7.3) — names the entity in a potentially-evaluated expression (6.2) where the enclosing full-expression depends on a generic lambda parameter declared within the reaching scope of the lambda-expression.
: 잠재적으로 평가되는 표현식(6.2)에서 엔티티의 이름을 명명한다.
여기에서 둘러싼 전체 표현식은 람다식의 도달 범위 내에 선언된 제너릭람다 파라미터에 의존적의다.

[Example:

void f(int, const int (&)[2] = {}) { } // #1

void f(const int&, const int (&)[1]) { } // #2

void test()
{
    const int x = 17;

    auto g = [](auto a)
    {
        f(x); // OK: calls #1, does not capture x
    };

    auto g2 = [=](auto a)
    {
        int selector[sizeof(a) == 1 ? 1 : 2]{};

        f(x, selector); // OK: is a dependent expression, so captures x
    };
}

— end example ] 

All such implicitly captured entities shall be declared within the reaching scope of the lambda expression. 
: 암시적이로 캡쳐된 엔티티들은 전부 람다식의 도달범위 내에서만 선언된다.

[ Note: The implicit capture of an entity by a nested lambda-expression can cause its implicit capture by the containing lambda-expression (see below). Implicit odr-uses of this can result in implicit capture. — end note ]
: 중첩된 람다식에 의한 엔티티의 암시적 캡쳐는 람다식을 포함해서 암시적으로 캡쳐할 수 있다.
: 중첩된 람다식에서 엔티티를 암시적으로 캡처하면 포함된 람다식(아래 참조)에 의한 암시 적 캡처가 발생할 수 있다.
이것을 암시적으로 odr-uses하면 암시적 캡처가 초래될 수 있다.

8 An entity is captured if it is captured explicitly or implicitly. 
: 그게 명시적이든, 암시적이든, 캡쳐가 된다면, 엔티티는 캡쳐된다.

An entity captured by a lambda-expression is odr-used (6.2) in the scope containing the lambda-expression. 
: 람다식에게 캡쳐된 엔티티는 람다식을 포함하는 스코프 내에서 odr-used된다.

If *this is captured by a local lambda expression, its nearest enclosing function shall be a non-static member function. 
: *this가 로컬람다식에게 캡쳐된다면, 가장 가까운 주변 함수는 비-정적 멤버함수다.

If a lambda-expression or an instantiation of the function call operator template of a generic lambda odr-uses (6.2) this or a variable with automatic storage duration from its reaching scope, that entity shall be captured by the lambda-expression.
: 람다식이나 제너릭람다의 함수호출연산자 템플릿의 인스턴스화는 this나 도달범위에서 자동저장기간으로 선언된 변수를 odr-uses한다.
그리고 그 엔티티는 람다식에게 캡쳐될 것이다.

If a lambda-expression captures an entity and that entity is not defined or captured in the immediately enclosing lambda expression or function, the program is ill-formed. 
: 람다식이 엔티티를 캡쳐했는데, 그 엔티티가 정의되지 않았거나 주변 람다식이나 함수 내에서 바로 캡쳐된다면, 그건 잘못된 형식이다.

[ Example:

void f1(int i)
{
    int const N = 20;

    auto m1 = [=]
    {
        int const M = 30;

        auto m2 = [i]
        {
            int x[N][M];
            // OK: N and M are not odr-used

            x[0][0] = i;
            // OK: i is explicitly captured by m2 and implicitly captured by m1
        };
    };

ㅤstruct s1
    {
        int f;

        void work(int n)
        {
            int m = n*n;

            int j = 40;

            auto m3 = [this,m]
            {
                auto m4 = [&,j]
                {    
                    // error: j not captured by m3

                    int x = n;
                    // error: n implicitly captured by m4 but not captured by m3

                    x += m;
                    // OK: m implicitly captured by m4 and explicitly captured by m3

                    x += i;
                    // error: i is outside of the reaching scope

                    x += f;
                    // OK: this captured implicitly by m4 and explicitly by m3

                };
            };
        }
    };
}

struct s2
{
    double ohseven = .007;

    auto f()
    {
        return [this]
        {
            return [*this]
            {
                return ohseven; // OK

            }
         }();
    }

    auto g()
    {
        return []
        {
            return [*this] { }; // error: *this not captured by outer lambda-expression
        }();
    }
};

— end example ]

9 A lambda-expression appearing in a default argument shall not implicitly or explicitly capture any entity.
: 디폴트인자에서 나타나는 람다식은 암시적으로든, 명시적으로든, 그 어떤 엔티티도 캡쳐할 수 없다.

[Example:

void f2()
{
    int i = 1;

    void g1(int = ([i]{ return i; })()); // ill-formed

    void g2(int = ([i]{ return 0; })()); // ill-formed

    void g3(int = ([=]{ return i; })()); // ill-formed

ㅤvoid g4(int = ([=]{ return 0; })()); // OK

    void g5(int = ([]{ return sizeof i; })()); // OK
}

— end example ]

10 An entity is captured by copy if
: 엔티티가 복사로 캡쳐되는 경우:

(10.1) — it is implicitly captured, the capture-default is =, and the captured entity is not *this, or
: 암시적으로 캡체되고, 캡쳐디폴트가 =이고 캡쳐된 엔티티가 *this가 아니거나

(10.2) — it is explicitly captured with a capture that is not of the form this, & identifier, or & identifier initializer.
&식별자나 &식별자 이니셜라이저, this가 아닌 형식의 캡쳐로 명시적으로 캡쳐될 때,

For each entity captured by copy, an unnamed non-static data member is declared in the closure type. 
: 복사로 캡쳐된 각각의 엔티티는 클로저타입 내에 선언된 이름없는 비-정적 데이터 멤버이다.

The declaration order of these members is unspecified. 
: 이 멤버들의 선언 순서는 명시되지 않는다.

The type of such a data member is the referenced type if the entity is a reference to an object, an lvalue reference to the referenced function type if the entity is a reference to a function, or the type of the corresponding captured entity otherwise. 
: 그 엔티티가 객체를 참조한다면 데이터멤버의 타입은 참조된 타입이며,
만약 그 엔티티가 함수를 참조하거나 해당하는 캡쳐된 엔티티의 타입이라면, 참조된 함수타입의 왼값참조다.

A member of an anonymous union shall not be captured by copy.
: 익명 공용체의 멤버는 복사로 캡쳐될 수 없다.

11 Every id-expression within the compound-statement of a lambda-expression that is an odr-use (6.2) of an entity captured by copy is transformed into an access to the corresponding unnamed data member of the closure type. 
: 복사로 캡쳐된 엔티티가 odr-use인 람다식 복합 구문 내의 모든 id표현식은 해당하는 클로저타입의 이름없는 데이터멤버로의 접근으로 변환된다.

[ Note: An id-expression that is not an odr-use refers to the original entity, never to a member of the closure type. Furthermore, such an id-expression does not cause the implicit capture of the entity. — end note ] 
: odr-use가 아닌 id표현식은 원래 엔티티의 참조를 사용하지, 클로저타입의 멤버를 참조하지 않는다.
게다가 id표현식은 엔티티의 암시적 캡쳐를 발생시키지 않는다.

If *this is captured by copy, each odr-use of this is transformed into a pointer to the corresponding unnamed data member of the closure type, cast (8.4) to the type of this. 
*this가 복사로 캡쳐된다면, this의 odr-use는 각각 해당하는 클로저타입의 데이터멤버에 대한 포인터로 변환이 되며, this의 타입으로 캐스팅된다.

[ Note: The cast ensures that the transformed expression is a prvalue. — end note ] 
: 이 캐스팅은 변환된 표현식이 순수 오른값임을 보장한다.

An id-expression within the compound-statement of a lambda-expression that is an odr-use of a reference captured by reference refers to the entity to which the captured reference is bound and not to the captured reference. 
: 참조에 의해 캡쳐된 참조의 odr-use인 람다식 복합구문 내 id표현식은 캡쳐된 레퍼런스가 바인딩된 엔티티만 참조하고, 캡쳐된 레퍼런스는 참조하지 않는다.

[ Note: The validity of such captures is determined by the lifetime of the object to which the reference refers, not by the lifetime of the reference itself. — end note ] 
: 그런 캡쳐의 유효성은 참조가 참조하는 객체의 생명주기에 의해 결정되지, 참조 그 자체의 생명주기로 결정되지는 않는다.

[Example:

void f(const int*);

void g()
{
    const int N = 10;

    [=]
    {
        int arr[N];
        // OK: not an odr-use, refers to automatic variable
        // odr-use가 아님, 자동변수를 참조함.

        f(&N); // OK: causes N to be captured; &N points to

        // the corresponding member of the closure type
    };
}

auto h(int &r)
{
    return [&]
    {
        ++r;
        // Valid after h returns if the lifetime of the

        // object to which r is bound has not ended
    };
}

— end example ]

12 An entity is captured by reference if it is implicitly or explicitly captured but not captured by copy. 
: 암시적이든 명시적이든 캡쳐만 된다면, 엔티티는 참조로 캡쳐가 되지만, 복사로 캡쳐되지는 않는다.

It is unspecified whether additional unnamed non-static data members are declared in the closure type for entities captured by reference. 
: 추가적으로 이름없는 비-정적데이터멤버가 참조로 캡쳐된 엔티티에 대한 클로저타입 내에 선언되는지 아닌지는 명시되지 않는다.

If declared, such non-static data members shall be of literal type. 
: 선언된다면, 그런 비-정적 데이터멤버는 리터럴 타입이 될 것이다.

[ Example:

// The inner closure type must be a literal type regardless of how reference captures are represented.
// 내부 클로저 타입은 참조캡쳐가 표현되는지와 상관없이 반드시 리터럴 타입이 된다.

static_assert([](int n)
{ return [&n] { return ++n; }(); }(3) == 4);

— end example ]

A bit-field or a member of an anonymous union shall not be captured by reference.
: 비트필드나 익명공용체의 멤버는 참조로 캡쳐될 수 없다.

13 If a lambda-expression m2 captures an entity and that entity is captured by an immediately enclosing lambda-expression m1, then m2’s capture is transformed as follows:
: 만약 람다식 m2가 엔티티를 캡쳐하고, 엔티티가 곧장 주변 람다식 m1에 의해 캡쳐된다면, m2의 캡쳐는 다음과 같이 변환될 것이다.

(13.1) — if m1 captures the entity by copy, m2 captures the corresponding non-static data member of m1’s closure type;
: 만약 m1이 복사로 엔티티를 캡쳐한다면, m2는 해당되는 m1의 클로저타입의 비-정적 데이터멤버를 캡쳐한다.

(13.2) — if m1 captures the entity by reference, m2 captures the same entity captured by m1.
: m1이 참조로 엔티티를 캡쳐한다면 m2는 m1가 캡쳐한 동일 엔티티를 캡쳐한다.

[Example: The nested lambda expressions and invocations below will output 123234.
: 중첩 람다식과 아래의 호출들은 123234를 출력할 것이다.

int a = 1, b = 1, c = 1;

auto m1 = [a, &b, &c]() mutable
{

    auto m2 = [a, b, &c]() mutable
    {
        std::cout << a << b << c;

        a = 4; b = 4; c = 4;
    };

    a = 3; b = 3; c = 3;

    m2();
};

a = 2; b = 2; c = 2;

m1();

std::cout << a << b << c;

— end example ]

14 Every occurrence of decltype((x)) where x is a possibly parenthesized id-expression that names an entity of automatic storage duration is treated as if x were transformed into an access to a corresponding data member of the closure type that would have been declared if x were an odr-use of the denoted entity. 
: decltype((x))의 모든 결과는
: decltype ((x))에서 x는 자동저장기간의 엔티티를 명명하는 괄호로 묶인 id표현식인데,
x가 표시된 엔티티의 odr-use라면,
x가 선언된 클로저타입의 해당되는 데이터 멤버에 대한 접근으로 변환된 것처럼 취급된다.

[ Example:

void f3()
{
    float x, &r = x;

    [=]
    {
        // x and r are not captured (appearance in a decltype operand is not an odr-use)
        // x와 r은 캡쳐되지 않는다. (decltype 피연산자에서 나타나는건 odr-use가 아니다.)

        decltype(x) y1; // y1 has type float

        decltype((x)) y2 = y1;
        // y2 has type float const& because this lambda is not mutable and x is an lvalue
        // y2는 이 람다가 mut가 아니고 x도 왼값이 아니기 때문에 float const&타입을 가진다.

        decltype(r) r1 = y1;
        // r1 has type float& (transformation not considered)
        // r1은 float&타입을 가진다. (변환은 고려되지 않음)

        decltype((r)) r2 = y2;
        // r2 has type float const&
        // r2는 float const&타입을 가진다.
    };
}

— end example ]

15 When the lambda-expression is evaluated, the entities that are captured by copy are used to direct-initialize each corresponding non-static data member of the resulting closure object, and the non-static data members corresponding to the init-captures are initialized as indicated by the corresponding initializer (which may be copy- or direct-initialization). 
: 람다식이 평가될 때, 복사로 캡쳐된 엔티티들은 결과로 나온 클로저객체의 각자 해당되는 비-정적 데이터타입으로 직접 초기화하는 것에 사용된다.
그리고 초기화캡쳐에 해당되는 비-정적 데이터멤버들은 해당하는 이니셜라이저에 의해 발생하는 것처럼 초기화된다.(복사나 직접초기화일 것임)

(For array members, the array elements are direct-initialized in increasing subscript order.) 
: 배열 멤버의 경우, 배열요소들은 증가하는 서브스크립트 순서로 직접초기화된다.

These initializations are performed in the (unspecified) order in which the non-static data members are declared. 
: 이 초기화는 비-정적 데이터멤버가 선언된 순서대로 수행된다.

[ Note: This ensures that the destructions will occur in the reverse order of the constructions. — end note ]
: 이것은 소멸작업이 생성의 역순으로 발생할 것임을 보장한다.