Lambda expressions (since C++11)

클로저 (스코프 내 변수를 캡처할 수 있는 이름 없는 함수 객체)를 생성합니다.

구문

명시적 템플릿 매개변수 목록이 없는 람다 표현식 (비제네릭일 수 있음)

명시적 템플릿 매개변수 목록을 갖는 람다 표현식 (항상 제네릭) (C++20부터)

설명

변수 __func__ 는 본문 시작 부분에 암시적으로 정의되며, 의미는 여기 에 설명된 대로입니다.

클로저 타입

람다 표현식은 고유한 이름 없는 비- union 비- aggregate 클래스 타입의 prvalue 표현식으로, closure type 이라고 알려져 있으며, 람다 표현식을 포함하는 가장 작은 블록 범위, 클래스 범위, 또는 네임스페이스 범위에서 ( ADL 목적으로) 선언됩니다.

클로저 타입은 다음과 같은 멤버들을 가지며, 이들은 명시적 인스턴스화 , 명시적 특수화 , 또는 (C++14 이후) 프렌드 선언 에서 이름을 지정할 수 없습니다:

// generic lambda, operator() is a template with two parameters
auto glambda = [](auto a, auto&& b) { return a < b; };
bool b = glambda(3, 3.14); // OK
// generic lambda, operator() is a template with one parameter
auto vglambda = [](auto printer)
{
    return [=](auto&&... ts) // generic lambda, ts is a parameter pack
    { 
        printer(std::forward<decltype(ts)>(ts)...);
        // nullary lambda (takes no parameters):
        return [=] { printer(ts...); };
    };
};
auto p = vglambda([](auto v1, auto v2, auto v3)
{
    std::cout << v1 << v2 << v3;
});
auto q = p(1, 'a', 3.14); // outputs 1a3.14
q();                      // outputs 1a3.14

// generic lambda, operator() is a template with two parameters
auto glambda = []<class T>(T a, auto&& b) { return a < b; };
// generic lambda, operator() is a template with one parameter pack
auto f = []<typename... Ts>(Ts&&... ts)
{
    return foo(std::forward<Ts>(ts)...);
};

struct X
{
    int x, y;
    int operator()(int);
    void f()
    {
        // 다음 람다의 컨텍스트는 멤버 함수 X::f입니다
        [=]() -> int
        {
            return operator()(this->x + y); // X::operator()(this->x + (*this).y)
                                            // this의 타입은 X*입니다
        };
    }
};

1. ↑ 함수 반환 타입 추론은 C++14에서 도입되었지만, 그 규칙은 C++11의 람다 반환 타입 추론에도 사용 가능합니다.

void f1(int (*)(int)) {}
void f2(char (*)(int)) {}
void h(int (*)(int)) {}  // #1
void h(char (*)(int)) {} // #2
auto glambda = [](auto a) { return a; };
f1(glambda); // OK
f2(glambda); // error: not convertible
h(glambda);  // OK: calls #1 since #2 is not convertible
int& (*fpi)(int*) = [](auto* a) -> auto& { return *a; }; // OK

auto Fwd = [](int(*fp)(int), auto a) { return fp(a); };
auto C = [](auto a) { return a; };
static_assert(Fwd(C, 3) == 3);  // OK
auto NC = [](auto a) { static int s; return a; };
static_assert(Fwd(NC, 3) == 3); // error: no specialization can be
                                // constexpr because of static s

람다 캡처

캡처 는 람다 함수 본문 내부에서 접근 가능한 외부 변수를 정의합니다. 구문은 다음과 같이 정의됩니다:

capture 의 구문은 다음과 같이 정의됩니다:

만약 capture-default 가 & 인 경우, 이후의 단순 캡처는 & 로 시작해서는 안 됩니다.

struct S2 { void f(int i); };
void S2::f(int i)
{
    [&] {};          // 정상: 참조에 의한 캡처 기본값
    [&, i] {};       // 정상: 참조에 의한 캡처, 단 i는 복사에 의해 캡처됨
    [&, &i] {};      // 오류: 참조 캡처가 기본값일 때 참조에 의한 캡처
    [&, this] {};    // 정상, [&]와 동등함
    [&, this, i] {}; // 정상, [&, i]와 동등함
}

만약 capture-default 가 = 인 경우, 이후의 단순 캡처들은 & 로 시작해야 하거나 *this 이어야 합니다 (C++17부터) 또는 this 이어야 합니다 (C++20부터) .

struct S2 { void f(int i); };
void S2::f(int i)
{
    [=] {};        // OK: 복사 캡처 기본값
    [=, &i] {};    // OK: 복사 캡처, 단 i는 참조로 캡처됨
    [=, *this] {}; // C++17까지: 오류: 잘못된 구문
                   // C++17부터: OK: 바깥쪽 S2를 복사로 캡처
    [=, this] {};  // C++20까지: 오류: =가 기본값일 때 this 사용
                   // C++20부터: OK, [=]와 동일
}

모든 캡처는 한 번만 나타날 수 있으며, 그 이름은 모든 매개변수 이름과 달라야 합니다:

struct S2 { void f(int i); };
void S2::f(int i)
{
    [i, i] {};        // 오류: i가 중복됨
    [this, *this] {}; // 오류: "this"가 중복됨 (C++17)
    [i] (int i) {};   // 오류: 매개변수와 캡처가 동일한 이름을 가짐
}

람다 표현식은 변수를 캡처하지 않고 사용할 수 있습니다. 만약 해당 변수가

• 비-지역 변수이거나 정적 또는 스레드 로컬 저장 기간 을 가지는 경우 (이 경우 변수는 캡처될 수 없음), 또는
• 상수 표현식 으로 초기화된 참조인 경우.

람다 표현식은 변수가 다음 조건을 만족할 때 캡처하지 않고도 해당 변수의 값을 읽을 수 있습니다

• const non-volatile 정수 또는 열거형 타입을 가지며 constant expression 으로 초기화되었거나,
• constexpr이며 mutable 멤버가 없는 경우.

현재 객체( * this )는 캡처 기본값이 존재하는 경우 암시적으로 캡처될 수 있습니다. 암시적으로 캡처되면, 캡처 기본값이 = 인 경우에도 항상 참조로 캡처됩니다. 캡처 기본값이 = 일 때 * this 의 암시적 캡처는 deprecated되었습니다. (since C++20)

다음 조건 중 하나를 만족하는 람다 표현식만이 초기화자가 없는 capture-default 또는 capture 를 가질 수 있습니다:

• 그것의 가장 안쪽 enclosing scope 는 block scope 입니다.
• 그것은 default member initializer 내에 나타나며, 가장 안쪽 enclosing scope는 해당 class scope 입니다.

이러한 람다 표현식의 경우, 도달 범위(reaching scope) 는 가장 안쪽의 enclosing function(및 해당 매개변수)까지 포함하는 enclosing scope들의 집합으로 정의됩니다. 여기에는 중첩된 블록 범위와 이 람다가 중첩된 경우 enclosing lambda들의 범위가 포함됩니다.

초기화자가 없는 캡처( this -캡처 제외)의 식별자 는 람다의 도달 범위(reaching scope) 에서 일반적인 비한정 이름 조회(unqualified name lookup) 를 사용하여 조회됩니다. 조회 결과는 도달 범위에서 선언된 자동 저장 기간을 가지는 변수 여야 하며 , 또는 해당 변수가 이러한 요구사항을 충족하는 구조化 바인딩(structured binding) (C++20부터) . 해당 엔티티는 명시적으로 캡처(explicitly captured) 됩니다.

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

만약 captures 가 capture-default 를 가지고 있고, 둘러싸는 객체( this 또는 * this )를 명시적으로 캡처하지 않거나, 람다 본문에서 odr-usable 인 자동 변수 , 또는 해당 변수가 원자적 저장 기간을 가지는 structured binding (C++20부터) 을 명시적으로 캡처하지 않으면, 해당 엔티티가 표현식 내에서 potentially-evaluated 표현식에 사용될 때(비정적 클래스 멤버 사용 앞에 암시적 this - > 가 추가되는 경우 포함) 엔티티를 암시적으로 캡처합니다.

암시적 캡처를 결정하기 위한 목적으로, typeid 는 피연산자를 평가되지 않은 상태로 만드는 것으로 간주되지 않습니다.

void f(int, const int (&)[2] = {}) {}   // #1
void f(const int&, const int (&)[1]) {} // #2
struct NoncopyableLiteralType
{
    constexpr explicit NoncopyableLiteralType(int n) : n_(n) {}
    NoncopyableLiteralType(const NoncopyableLiteralType&) = delete;
    int n_;
};
void test()
{
    const int x = 17;
    auto l0 = []{ f(x); };           // OK: #1을 호출하며, x를 캡처하지 않음
    auto g0 = [](auto a) { f(x); };  // 위와 동일
    auto l1 = [=]{ f(x); };          // OK: x를 캡처하고(P0588R1 이후) #1을 호출
                                     // 캡처는 최적화를 통해 제거될 수 있음
    auto g1 = [=](auto a) { f(x); }; // 위와 동일
    auto ltid = [=]{ typeid(x); };   // OK: x를 캡처함(P0588R1 이후)
                                     // x가 평가되지 않은 피연산자임에도 불구하고
                                     // 캡처는 최적화를 통해 제거될 수 있음
    auto g2 = [=](auto a)
    {
        int selector[sizeof(a) == 1 ? 1 : 2] = {};
        f(x, selector); // OK: 종속 표현식이므로 x를 캡처함
    };
    auto g3 = [=](auto a)
    {
        typeid(a + x);  // a + x가 평가되지 않은 피연산자인지 여부와 관계없이
                        // x를 캡처함
    };
    constexpr NoncopyableLiteralType w{42};
    auto l4 = []{ return w.n_; };      // OK: w는 odr-사용되지 않으며, 캡처가 필요하지 않음
    // auto l5 = [=]{ return w.n_; };  // 오류: w는 복사에 의해 캡처되어야 함
}

람다의 본문이 odr-uses 복사에 의해 캡처된 엔티티를 사용하는 경우, 클로저 타입의 멤버에 접근합니다. 엔티티를 odr-using하지 않는 경우, 접근은 원본 객체에 이루어집니다:

void f(const int*);
void g()
{
    const int N = 10;
    [=]
    { 
        int arr[N]; // odr-use가 아님: g의 const int N을 참조함
        f(&N); // odr-use: N이 캡처되도록 함(복사에 의해)
               // &N은 g의 N이 아닌 클로저 객체의 멤버 N의 주소임
    }();
}

람다가 참조로 캡처된 참조를 odr-사용하는 경우, 이는 캡처된 참조 자체가 아닌 원본 참조가 참조하는 객체를 사용하는 것입니다:

#include <iostream>
auto make_function(int& x)
{
    return [&] { std::cout << x << '\n'; };
}
int main()
{
    int i = 3;
    auto f = make_function(i); // f에서 x의 사용은 i에 직접 바인딩됩니다
    i = 5;
    f(); // OK: 5를 출력합니다
}

캡처 기본값 = 를 가진 람다 본문 내에서는, 캡처 가능한 모든 엔티티의 타입은 마치 캡처된 것처럼 처리됩니다(따라서 람다가 mutable 가 아닌 경우 const 한정자가 종종 추가됩니다). 비록 해당 엔티티가 평가되지 않은 피연산자에 있고 실제로 캡처되지 않은 경우에도(예: decltype 내에서) 이 규칙이 적용됩니다:

void f3()
{
    float x, &r = x;
    [=]
    { // x와 r은 캡처되지 않음 (decltype 피연산자 내 등장은 odr-use가 아님)
        decltype(x) y1;        // y1은 float 타입을 가짐
        decltype((x)) y2 = y1; // y2는 float const& 타입을 가짐. 왜냐하면 이 람다는
                               // mutable이 아니고 x는 lvalue이기 때문
        decltype(r) r1 = y1;   // r1은 float& 타입을 가짐 (변환은 고려되지 않음)
        decltype((r)) r2 = y2; // r2는 float const& 타입을 가짐
    };
}

람다에 의해 캡처된(암시적으로 또는 명시적으로) 모든 엔티티는 람다 표현식에 의해 odr-used됩니다(따라서 중첩된 람다에 의한 암시적 캡처는 둘러싸는 람다에서 암시적 캡처를 트리거합니다).

암시적으로 캡처된 모든 변수는 람다의 도달 범위(reaching scope) 내에서 선언되어야 합니다.

람다가 둘러싼 객체를 캡처하는 경우( this 또는 * this ), 가장 가까운 둘러싼 함수는 비정적 멤버 함수이거나 람다는 기본 멤버 초기화자 내에 있어야 합니다:

struct s2
{
    double ohseven = .007;
    auto f() // 다음 두 람다를 위한 가장 가까운 둘러싸는 함수
    {
        return [this]      // 둘러싸는 s2를 참조로 캡처
        {
            return [*this] // 둘러싸는 s2를 복사로 캡처 (C++17)
            {
                return ohseven; // OK
            }
        }();
    }
    auto g()
    {
        return [] // 아무것도 캡처하지 않음
        { 
            return [*this] {}; // 오류: *this가 외부 람다 표현식에 의해 캡처되지 않음
        }();
    }
};

람다 표현식이 (또는 제네릭 람다의 함수 호출 연산자 특수화) (since C++14) ODR-사용하는 경우 * this 또는 자동 저장 기간을 가진 모든 변수는 반드시 람다 표현식에 의해 캡처되어야 합니다.

void f1(int i)
{
    int const N = 20;
    auto m1 = [=]
    {
        int const M = 30;
        auto m2 = [i]
        {
            int x[N][M]; // N과 M은 odr-사용되지 않음
                         // (캡처되지 않아도 문제없음)
            x[0][0] = i; // i는 m2에 의해 명시적으로 캡처됨
                         // 그리고 m1에 의해 암시적으로 캡처됨
        };
    };
    struct s1 // f1() 내부의 지역 클래스
    {
        int f;
        void work(int n) // 비정적 멤버 함수
        {
            int m = n * n;
            int j = 40;
            auto m3 = [this, m]
            {
                auto m4 = [&, j] // 오류: j는 m3에 의해 캡처되지 않음
                {
                    int x = n; // 오류: n은 m4에 의해 암시적으로 캡처되지만
                               // m3에 의해 캡처되지 않음
                    x += m;    // OK: m은 m4에 의해 암시적으로 캡처되고
                               // m3에 의해 명시적으로 캡처됨
                    x += i;    // 오류: i는 도달 범위를 벗어남
                               // (범위는 work()에서 끝남)
                    x += f;    // OK: this는 m4에 의해 암시적으로 캡처되고
                               // m3에 의해 명시적으로 캡처됨
                };
            };
        }
    };
}

클래스 멤버는 초기화자 없이 캡처에서 명시적으로 캡처될 수 없습니다 (위에서 언급한 바와 같이, variables 만이 capture-list 에 허용됩니다):

class S
{
    int x = 0;
    void f()
    {
        int i = 0;
    //  auto l1 = [i, x] { use(i, x); };      // 오류: x는 변수가 아님
        auto l2 = [i, x = x] { use(i, x); };  // OK, 복사 캡처
        i = 1; x = 1; l2(); // use(0,0) 호출
        auto l3 = [i, &x = x] { use(i, x); }; // OK, 참조 캡처
        i = 2; x = 2; l3(); // use(1,2) 호출
    }
};

람다가 암시적 복사 캡처를 사용하여 멤버를 캡처할 때, 해당 멤버 변수의 복사본을 만들지 않습니다: 멤버 변수 m 의 사용은 ( * this ) . m 표현식으로 처리되며, * this 는 항상 암시적으로 참조로 캡처됩니다:

class S
{
    int x = 0;
    void f()
    {
        int i = 0;
        auto l1 = [=] { use(i, x); }; // i의 복사본과 this 포인터의 복사본을 캡처합니다
                                      //
        i = 1; x = 1; l1();           // use(0, 1)을 호출합니다, 마치
                                      // i는 복사로, x는 참조로 전달된 것처럼
        auto l2 = [i, this] { use(i, x); }; // 위와 동일하며, 명시적으로 표현되었습니다
        i = 2; x = 2; l2();           // use(1, 2)을 호출합니다, 마치
                                      // i는 복사로, x는 참조로 전달된 것처럼
        auto l3 = [&] { use(i, x); }; // i를 참조로 캡처하고
                                      // this 포인터의 복사본을 캡처합니다
        i = 3; x = 2; l3();           // use(3, 2)을 호출합니다, 마치
                                      // i와 x 모두 참조로 전달된 것처럼
        auto l4 = [i, *this] { use(i, x); }; // *this의 복사본을 생성하며,
                                             // x의 복사본을 포함합니다
        i = 4; x = 4; l4();           // use(3, 2)을 호출합니다, 마치
                                      // i와 x 모두 복사로 전달된 것처럼
    }
};

람다 표현식이 기본 인수 에 나타나는 경우, 명시적 또는 암시적으로 아무것도 캡처할 수 없습니다 , 모든 캡처가 기본 인수에 나타나는 표현식의 제약 조건을 만족하는 초기화자를 갖는 경우는 제외 (C++14부터) :

void f2()
{
    int i = 1;
    void g1( int = [i] { return i; }() ); // 오류: 무언가를 캡처함
    void g2( int = [i] { return 0; }() ); // 오류: 무언가를 캡처함
    void g3( int = [=] { return i; }() ); // 오류: 무언가를 캡처함
    void g4( int = [=] { return 0; }() );       // OK: 캡처 없음
    void g5( int = [] { return sizeof i; }() ); // OK: 캡처 없음
    // C++14
    void g6( int = [x = 1] { return x; }() ); // OK: 1은 기본 인수에 나타날 수 있음
                                              //     
    void g7( int = [x = i] { return x; }() ); // 오류: i는 기본 인수에 나타날 수 없음
                                              //        
}

익명 공용체 멤버들은 캡처될 수 없습니다. 비트 필드 는 복사에 의해서만 캡처될 수 있습니다.

중첩된 람다 m2 가 바로 바깥쪽 람다 m1 에서도 캡처하는 대상을 캡처하는 경우, m2 의 캡처는 다음과 같이 변환됩니다:

• 바깥쪽 람다 m1 이 복사로 캡처하는 경우, m2 는 원본 변수나 * this 가 아닌 m1 의 클로저 타입의 비정적 멤버를 캡처합니다; m1 이 mutable이 아닌 경우, 비정적 데이터 멤버는 const 한정된 것으로 간주됩니다.
• 바깥쪽 람다 m1 이 참조로 캡처하는 경우, m2 는 원본 변수나 * this 를 캡처합니다.

#include <iostream>
int main()
{
    int a = 1, b = 1, c = 1;
    auto m1 = [a, &b, &c]() mutable
    {
        auto m2 = [a, b, &c]() mutable
        {
            std::cout << a << b << c << '\n';
            a = 4; b = 4; c = 4;
        };
        a = 3; b = 3; c = 3;
        m2();
    };
    a = 2; b = 2; c = 2;
    m1();                             // m2()를 호출하고 123을 출력
    std::cout << a << b << c << '\n'; // 234를 출력
}

struct C 
{
    template<typename T>
    C(T);
};
void func(int i) 
{
    int x = [=](this auto&&) { return i; }();  // OK
    int y = [=](this C) { return i; }();       // error
    int z = [](this C) { return 42; }();       // OK
    auto lambda = [n = 42] (this auto self) { return n; };
    using Closure = decltype(lambda);
    struct D : private Closure {
        D(Closure l) : Closure(l) {}
        using Closure::operator();
        friend Closure;
    };
    D{lambda}(); // error
}

참고 사항

암시적 람다 캡처 규칙은 결함 보고서 P0588R1 에 의해 약간 변경되었습니다. 2023년 10월 기준으로, 일부 주요 구현체들이 이 DR을 완전히 구현하지 않았기 때문에, odr-use 를 감지하는 이전 규칙이 여전히 일부 경우에 사용됩니다.

예제

#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> c{1, 2, 3, 4, 5, 6, 7};
    int x = 5;
    c.erase(std::remove_if(c.begin(), c.end(), [x](int n) { return n < x; }), c.end());
    std::cout << "c: ";
    std::for_each(c.begin(), c.end(), [](int i) { std::cout << i << ' '; });
    std::cout << '\n';
    // 클로저의 타입은 이름을 지정할 수 없지만, auto로 추론할 수 있습니다
    // C++14부터, 람다는 기본 인자를 가질 수 있습니다
    auto func1 = [](int i = 6) { return i + 4; };
    std::cout << "func1: " << func1() << '\n';
    // 모든 호출 가능 객체와 마찬가지로, 클로저는 std::function에 캡처될 수 있습니다
    // (이것은 불필요한 오버헤드를 발생시킬 수 있습니다)
    std::function<int(int)> func2 = [](int i) { return i + 4; };
    std::cout << "func2: " << func2(6) << '\n';
    constexpr int fib_max {8};
    std::cout << "재귀적 람다 호출을 에뮬레이션:\n피보나치 수열: ";
    auto nth_fibonacci = [](int n)
    {
        std::function<int(int, int, int)> fib = [&](int n, int a, int b)
        {
            return n ? fib(n - 1, a + b, a) : b;
        };
        return fib(n, 0, 1);
    };
    for (int i{1}; i <= fib_max; ++i)
        std::cout << nth_fibonacci(i) << (i < fib_max ? ", " : "\n");
    std::cout << "람다 재귀에 대한 대체 접근법:\n피보나치 수열: ";
    auto nth_fibonacci2 = [](auto self, int n, int a = 0, int b = 1) -> int
    {
        return n ? self(self, n - 1, a + b, a) : b;
    };
    for (int i{1}; i <= fib_max; ++i)
        std::cout << nth_fibonacci2(nth_fibonacci2, i) << (i < fib_max ? ", " : "\n");
#ifdef __cpp_explicit_this_parameter
    std::cout << "C++23의 람다 재귀 접근법:\n";
    auto nth_fibonacci3 = [](this auto self, int n, int a = 0, int b = 1) -> int
    {
         return n ? self(n - 1, a + b, a) : b;
    };
    for (int i{1}; i <= fib_max; ++i)
        std::cout << nth_fibonacci3(i) << (i < fib_max ? ", " : "\n");
#endif
}

c: 5 6 7
func1: 10
func2: 10
`재귀적 람다` 호출 에뮬레이션:
피보나치 수: 0, 1, 1, 2, 3, 5, 8, 13
람다 재귀에 대한 대체 접근법:
피보나치 수: 0, 1, 1, 2, 3, 5, 8, 13

결함 보고서

다음의 동작 변경 결함 보고서들은 이전에 발표된 C++ 표준에 소급 적용되었습니다.

참고 항목

외부 링크