람다 표현식

이번 장에서는 람다 표현식(Lambda Expressions)의 문법, 캡처 방식, STL 알고리즘에서의 사용 패턴을 다룹니다.

람다 표현식은 C++11에서 도입되었으며, 코드 내에서 짧은 함수를 즉석에서 정의하고 사용할 수 있게 해줍니다.

이는 특히 STL 알고리즘과 함께 사용할 때 코드의 가독성과 유연성을 높입니다.

12장 4절에서 함수 객체(Functors)를 잠깐 다루면서 람다를 언급했지만, 여기서는 람다의 모든 면모를 깊이 있게 탐구할 것입니다.

람다 표현식이란 무엇인가?

람다 표현식은 이름이 없는(익명) 함수 객체(Functor)를 코드 내에서 즉석으로 생성하는 방법입니다.

즉, 별도의 클래스를 정의하거나 전역 함수를 만들 필요 없이, 필요한 곳에 바로 함수처럼 호출할 수 있는 객체를 만들 수 있습니다.

• STL 알고리즘(std::sort, std::for_each, std::transform, std::find_if 등)은 사용자 정의 동작을 위해 함수 포인터나 함수 객체를 인자로 받습니다.
• 함수 포인터는 상태(멤버 변수)를 가질 수 없고, 함수 객체는 작은 함수를 위해 별도의 클래스를 정의해야 하는 번거로움이 있었습니다.
• 람다 표현식은 이러한 불편함을 해소하고, 인라인으로 함수 객체를 생성할 수 있게 하여 코드를 훨씬 간결하고 의미 있게 만듭니다.

[캡처](매개변수) -> 반환타입 {
    // 함수 본문
}

• [캡처] (Capture Clause): 람다 본문 내에서 람다 외부의 변수를 사용할 수 있도록 지정하는 부분입니다. 람다의 핵심 기능 중 하나입니다.
• (매개변수) (Parameter List): 일반 함수처럼 람다가 받을 매개변수 목록입니다.
• -> 반환타입 (Return Type): 람다의 반환 타입입니다. 보통 생략할 수 있으며, 컴파일러가 본문에서 추론합니다. 반환 타입이 복잡하거나 명시적으로 지정하고 싶을 때 사용합니다.
• { 함수 본문 } (Function Body): 람다가 실행할 코드 블록입니다.

캡처 절 (Capture Clause) 상세 분석

캡처 절은 값 복사, 원본 참조, 객체 수명 분리를 기준으로 읽으면 각 표기법의 차이가 선명해집니다.

캡처 절은 람다 표현식이 외부 스코프의 변수를 어떻게 사용할 것인지 결정합니다.

#include <iostream>

int main() {
    int x = 10;
    auto func = [](int a, int b) {
        // std::cout << x; // 컴파일 오류: x를 캡처하지 않음
        return a + b;
    };
    std::cout << func(1, 2) << std::endl; // 출력: 3
    return 0;
}

#include <iostream>

int main() {
    int x = 10;
    auto func = [x](int a) {
        // x++; // 컴파일 오류: 값으로 캡처된 변수는 기본적으로 const
        return a + x;
    };
    x = 20; // 람다 내부의 x는 영향을 받지 않음
    std::cout << func(5) << std::endl; // 출력: 15 (5 + 10)
    return 0;
}

#include <iostream>

int main() {
    int x = 10;
    auto func = [x](int a) mutable { // mutable 키워드 추가
        x++; // 이제 람다 내부의 x는 수정 가능 (원본 x와 별개)
        return a + x;
    };
    std::cout << func(5) << std::endl; // 출력: 16 (5 + 11)
    std::cout << x << std::endl;      // 출력: 10 (원본 x는 변함 없음)
    return 0;
}

#include <iostream>

int main() {
    int x = 10;
    auto func = [&x](int a) { // x를 참조로 캡처
        x++; // 원본 x를 변경
        return a + x;
    };
    std::cout << func(5) << std::endl; // 출력: 16 (5 + 11)
    std::cout << x << std::endl;      // 출력: 11 (원본 x가 변경됨)
    return 0;
}

#include <iostream>

int main() {
    int x = 10;
    int y = 20;
    auto func = [=](int a) { // x, y 모두 값으로 캡처
        return a + x + y;
    };
    std::cout << func(5) << std::endl; // 출력: 35
    return 0;
}

#include <iostream>

int main() {
    int x = 10;
    int y = 20;
    auto func = [&](int a) { // x, y 모두 참조로 캡처
        x++;
        y--;
        return a + x + y;
    };
    std::cout << func(5) << std::endl; // 출력: 35 (a=5, x=11, y=19)
    std::cout << "x: " << x << ", y: " << y << std::endl; // 출력: x: 11, y: 19
    return 0;
}

#include <iostream>

int main() {
    int x = 10;
    int y = 20;
    auto func = [x, &y](int a) { // x는 값으로, y는 참조로
        // x++; // 오류: x는 const로 캡처됨
        y++; // y는 수정 가능
        return a + x + y;
    };
    std::cout << func(5) << std::endl; // 출력: 36 (a=5, x=10, y=21)
    std::cout << "x: " << x << ", y: " << y << std::endl; // 출력: x: 10, y: 21
    return 0;
}

람다 표현식의 활용 사례

람다 표현식은 주로 STL 알고리즘과 함께 사용될 때 그 진가를 발휘합니다.

#include <iostream>
#include <vector>
#include <algorithm> // sort
#include <string>

struct Person {
    std::string name;
    int age;
};

int main() {
    std::vector<Person> people = {
        {"Alice", 30},
        {"Charlie", 25},
        {"Bob", 35}
    };

    // 나이 기준 오름차순 정렬 (람다 사용)
    std::sort(people.begin(), people.end(), [](const Person& p1, const Person& p2) {
        return p1.age < p2.age;
    });

    std::cout << "Sorted by age:\n";
    for (const auto& p : people) {
        std::cout << p.name << " (" << p.age << ")\n";
    }
    // 출력:
    // Charlie (25)
    // Alice (30)
    // Bob (35)
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm> // find_if

int main() {
    std::vector<int> numbers = {10, 25, 30, 45, 50};

    // 30보다 큰 첫 번째 요소 찾기
    auto it = std::find_if(numbers.begin(), numbers.end(), [](int n) {
        return n > 30;
    });

    if (it != numbers.end()) {
        std::cout << "First number greater than 30: " << *it << std::endl; // 출력: 45
    } else {
        std::cout << "No number greater than 30 found.\n";
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm> // count_if

int main() {
    std::vector<int> scores = {85, 92, 78, 65, 95, 80};
    int min_score = 90; // 외부 변수

    // min_score 이상인 점수의 개수 세기
    int count_above_min = std::count_if(scores.begin(), scores.end(), [min_score](int s) {
        return s >= min_score;
    });

    std::cout << "Number of scores >= " << min_score << ": " << count_above_min << std::endl; // 출력: 2 (92, 95)
    return 0;
}

람다 표현식의 장점

• 간결성: 작은 함수 객체를 즉석에서 정의할 수 있어 코드의 양이 줄어듭니다.
• 가독성: 함수 정의가 사용되는 곳 바로 옆에 위치하므로, 코드의 의도를 파악하기 쉽습니다.
• 유연성: 외부 스코프의 변수를 캡처할 수 있어, 더 복잡하고 유연한 조건을 표현할 수 있습니다.
• 성능: 컴파일러가 람다를 인라인 처리하거나 최적화하기 더 쉬워, 함수 포인터보다 성능 이점을 가질 수 있습니다.

auto와 람다의 조합

auto 키워드는 람다 표현식의 고유 타입을 간결하게 유지하는 데 사용됩니다.

람다의 실제 타입은 컴파일러가 생성하는 고유한 이름 없는 타입이므로, auto로 고유 타입을 유지해 저장할 수 있습니다. 람다를 직접 함수 인자로 넘기거나 std::function으로 감싸는 방법도 가능합니다.

#include <iostream>
#include <functional> // std::function (선택적)

int main() {
    auto my_lambda = [](int a, int b) { return a * b; }; // auto로 람다 타입 추론

    std::cout << my_lambda(6, 7) << std::endl; // 출력: 42

    // (참고) C++11에서는 람다를 std::function 객체로 감쌀 수 있습니다.
    // 타입 소거를 통해 지정한 호출 시그니처로 보관합니다. 함수 포인터와 같은 타입은 아닙니다.
    std::function<int(int, int)> func_wrapper = [](int a, int b) { return a / b; };
    std::cout << func_wrapper(10, 2) << std::endl; // 출력: 5
    return 0;
}

람다의 한계 및 주의점

• 복잡성: 람다 본문이 너무 길어지거나 복잡해지면, 차라리 별도의 명명된 함수나 함수 객체 클래스로 분리하는 것이 가독성 면에서 더 좋습니다. 람다는 짧고 한 번 사용할 함수에 가장 적합합니다.
• 생명 주기: 참조 캡처([&], [&var])를 사용할 때는 캡처된 변수의 생명 주기에 주의해야 합니다. 람다가 캡처된 변수보다 오래 살아남는 경우, 댕글링 참조(Dangling Reference) 문제가 발생하여 정의되지 않은 동작을 초래할 수 있습니다.

  #include <iostream>
  // 위험한 예시:
  auto create_lambda() {
      int local_var = 10;
      return [&local_var]() { // local_var를 참조 캡처
          std::cout << local_var << std::endl;
      };
  }
  int main() {
      auto lambda = create_lambda(); // create_lambda() 종료 시 local_var 소멸
      // lambda(); // 여기서는 local_var가 이미 소멸된 상태이므로 위험!
      return 0;
  }

이러한 문제를 피하려면 값 캡처([=], [var])를 사용하거나, std::shared_ptr 같은 스마트 포인터를 사용하여 객체의 생명 주기를 관리해야 합니다.

[x](int a) { return a + x; }

[&local_var]() {
  return local_var;
}

[this]  // 원본 객체 필요
[*this] // 객체 복사

[p = std::move(ptr)]() {
  return *p;
}

[x](int a) { return a + x; }

[&local_var]() {
  return local_var;
}

[this]  // 원본 객체 필요
[*this] // 객체 복사

[p = std::move(ptr)]() {
  return *p;
}

람다를 저장하거나 비동기로 넘길 가능성이 있다면 [&] 같은 기본 참조 캡처를 먼저 의심해야 합니다.

캡처 목록을 좁히고, 값 캡처나 소유권이 드러나는 스마트 포인터 캡처로 수명을 분리하는 편이 안전합니다.

예시: 람다 복사본의 상태는 어디에 남을까?

mutable은 값으로 캡처한 람다 내부 상태를 바꿀 수 있게 합니다. 원래 바깥 변수를 참조 캡처로 바꾸는 기능은 아닙니다. 다음 C++17 파일은 호출 순서를 문장별로 고정해 두 람다 객체의 상태를 비교합니다.

#include <iostream>

int main() {
    int x = 10;
    auto counter = [x]() mutable { return ++x; };
    auto other = counter;
    int first = counter();
    int second = counter();
    int copiedFirst = other();
    std::cout << first << ' ' << second << ' ' << copiedFirst << ' ' << x << '\n';
}

출력은 11 12 11 10입니다. 람다를 만들 때 counter의 캡처 값은 10이고, other를 복사할 때도 10입니다. 첫 두 호출은 counter 안의 정수만 11, 12로 바꾸고, 세 번째 호출은 other 안의 정수를 처음으로 11로 바꿉니다. 바깥 x는 여전히 10입니다. 캡처 대상이 정수인 이 사례에서는 두 복사본의 상태가 독립적입니다. 포인터나 shared_ptr를 값 캡처하면 포인터 값·소유자를 복사하는 것이므로 가리키는 객체까지 별도로 복제된다는 뜻은 아닙니다.

앞의 위험한 반환 람다에서 지역 정수를 참조 캡처하면 함수 종료 뒤 참조 대상이 사라집니다. 정수 값을 반환 람다 안에 보관하려는 목적이라면 [local_var]로 값 캡처할 수 있습니다. 그 경우에도 캡처한 값이 포인터라면 대상 객체의 수명은 별도로 확인해야 합니다.

독립 연습

위 코드의 x를 3으로 바꾸고, auto other = counter;를 첫 번째 counter() 호출 직후로 옮깁니다. 이후 두 번째 counter()와 첫 번째 other()를 호출했을 때 세 반환 값과 바깥 x는 얼마일까요? 별도 실험에서 캡처만 [&x]로 바꾸고 같은 순서로 실행하면 무엇이 달라질까요? 두 실험 모두 x가 살아 있는 main 안에서만 호출합니다.

이 차이는 클로저의 호출 연산자·복사 생성과 값·참조 캡처 및 대상 수명의 규칙에 해당합니다.