[2026] C++ Lambdas: Syntax, Captures, mutable, and Generic Lambdas

· 10분 읽기 · 수정 Intermediate tutorial
[2026] C++ Lambdas: Syntax, Captures, mutable, and Generic Lambdas

이 글의 핵심

Complete guide to C++ lambda expressions: capture lists, mutable lambdas, C++14 generic lambdas, STL algorithms, and common pitfalls (dangling captures).

Basic grammar

Lambdas are useful when you want to put short function logic in one place for STL algorithms and asynchronous callbacks.In this article, you can learn how to select the capture list and return type by following the grammar and capture examples in the following sections in order. 다음은 cpp를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// Basic form
auto lambda = [] {
    cout << "Hello Lambda!" << endl;
};
lambda();  // call
// Parameters and return type
auto add = [](int a, int b) -> int {
    return a + b;
};
cout << add(3, 5) << endl;  // 8
// Deduced return type
auto multiply = [](int a, int b) {
    return a * b;  // int
};

Capture

Value Capture

아래 코드는 cpp를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

int x = 10;
int y = 20;
// capture by value
auto lambda1 = [x, y]() {
cout << x + y << endl;
};
// Capture all variables by value
auto lambda2 = [=]() {
cout << x + y << endl;
};

Reference Capture

아래 코드는 cpp를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

int count = 0;
// capture by reference
auto increment = [&count]() {
count++;
};
increment();
cout << count << endl;  // 1
// Capture all variables by reference
auto lambda = [&]() {
count++;
};

Mixed Capture

아래 코드는 cpp를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

int x = 10;
int y = 20;
// x is the value, y is the reference
auto lambda = [x, &y]() {
y = x + 5;
};
lambda();
cout << y << endl;// 15

mutable lambda

다음은 cpp를 활용한 상세한 구현 코드입니다. 에러 처리를 통해 안정성을 확보합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

int x = 10;
// value capture is const by default
auto lambda1 = [x]() {
//x++;// error!const
};
// Can be modified with mutable
auto lambda2 = [x]() mutable {
x++;// OK (edit copy)
cout << x << endl;
};
lambda2();// 11
cout << x << endl;// 10 (original unchanged)

Practical example

Example 1: STL algorithm and lambda

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// Keep only evens
auto it = remove_if(numbers.begin(), numbers.end(), [](int x) {
    return x % 2 != 0;
});
numbers.erase(it, numbers.end());
// Print
for_each(numbers.begin(), numbers.end(), [](int x) {
    cout << x << " ";
});
cout << endl;  // 2 4 6 8 10
// Sort descending
sort(numbers.begin(), numbers.end(), [](int a, int b) {
    return a > b;
});
// Check predicate
bool allEven = all_of(numbers.begin(), numbers.end(), [](int x) {
    return x % 2 == 0;
});
cout << "all even: " << allEven << endl;
return 0;
}

Description: Lambdas allow you to write simple logic inline without a separate function.

Example 2: Event handler

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <iostream>
#include <vector>
#include <functional>
using namespace std;
class Button {
private:
string label;
function<void()> onClick;
public:
Button(string l) : label(l) {}
void setOnClick(function<void()> handler) {
onClick = handler;
}
void click() {
cout << label << "Click!"<< endl;
if (onClick) {
onClick();
}
}
};
int main() {
int clickCount = 0;
Button btn1("Button1");
btn1.setOnClick([&clickCount]() {
clickCount++;
cout << "Click count: " << clickCount << endl;
});
Button btn2("Button2");
btn2.setOnClick([]{
    cout << "Button 2 was clicked!" << endl;
});
btn1.click();
btn1.click();
btn2.click();
return 0;
}

Description: You can register event handlers succinctly with lambdas.

Example 3: Generic lambda (C++14)

다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 반복문으로 데이터를 처리합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main() {
// Generic lambda (auto parameters)
auto print = [](auto x) {
    cout << x << endl;
};
print(10);       // int
print(3.14);     // double
print("Hello");  // const char*
auto add = [](auto a, auto b) {
    return a + b;
};
cout << add(1, 2) << endl;
cout << add(1.5, 2.5) << endl;
cout << add(string("Hello"), string(" World")) << endl;
auto printVector = [](const auto& vec) {
    for (const auto& item : vec) {
        cout << item << " ";
    }
    cout << endl;
};
vector<int> v1 = {1, 2, 3};
vector<string> v2 = {"a", "b", "c"};
printVector(v1);// 1 2 3
printVector(v2);// a b c
return 0;
}

Explanation: Starting with C++14, you can create a generic lambda with an auto parameter.

Frequently occurring problems

Problem 1: Dangling References

Symptom: Crash or strange values when running lambda Cause: The reference-captured variable has already been destroyed. Fix: 다음은 cpp를 활용한 상세한 구현 코드입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// ❌ Dangerous code
function<void()> makeCounter() {
int count = 0;
return [&count]() { // See dangling!
count++;
cout << count << endl;
};
}
auto counter = makeCounter();
counter();// crash or strange value
// ✅ Capture by value
function<void()> makeCounter() {
int count = 0;
return [count]() mutable {
count++;
cout << count << endl;
};
}

Problem 2: Capturing this

Symptom: Inability to access member variables Cause: Missing capture of this Solution: 다음은 cpp를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

class Counter {
private:
int count = 0;
public:
void increment() {
    // ❌ Error: cannot reference members without capture
    // auto bad = [] { count++; };
    // ✅ Capture this
    auto lambda2 = [this]() {
        count++;
    };
    // ✅ C++17: copy *this
    auto lambda3 = [*this]() mutable {
        count++;  // modifies copy
    };
}
};

Issue 3: Capture initialization (C++14)

Symptom: Complex initialization is not possible Cause: Only simple capture is possible Solution: 아래 코드는 cpp를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.

// ❌ Not possible in C++11
unique_ptr<int> ptr = make_unique<int>(10);
auto lambda = [ptr]() { // Error!Unable to copy unique_ptr
cout << *ptr << endl;
};
// ✅ C++14: Capture initialization
unique_ptr<int> ptr = make_unique<int>(10);
auto lambda = [ptr = move(ptr)]() {
cout << *ptr << endl;
};

FAQ

Q1: When do you use lambda?

A:

  • Predicates of STL algorithm
  • Event handler
  • Callback function
  • Simple one-off function

Q2: Lambda vs function pointer?

A: Lambdas are more flexible and captureable.Function pointers are converted only to lambdas without capture.

Q3: What is the type of lambda?

A: Each lambda has a unique type.Save it as auto or function<>.

Q4: What is a recursive lambda?

A: Available starting from C++14.

function<int(int)> factorial = [&factorial](int n) {
return n <= 1 ?1 : n * factorial(n - 1);
};

Q5: Does lambda affect performance?

A: When inlined, there is very little overhead.Same performance as a regular function.

Q6: What are the capture defaults?

A:

  • [=]: all as values (not recommended, capture explicitly)
  • [&]: all by reference (Caution: risk of dangling references)
  • []: No capture (most secure)

Good article to read together (internal link)

Here’s another article related to this topic.

Practical tips

These are tips that can be applied right away in practice.

Debugging tips

  • If you run into a problem, check the compiler warnings first.
  • Reproduce the problem with a simple test case

Performance Tips

  • Don’t optimize without profiling
  • Set measurable indicators first

Code review tips

  • Check in advance for areas that are frequently pointed out in code reviews.
  • Follow your team’s coding conventions

Practical checklist

This is what you need to check when applying this concept in practice.

Before writing code

  • Is this technique the best way to solve the current problem?
  • Can team members understand and maintain this code?
  • Does it meet the performance requirements?

Writing code

  • Have you resolved all compiler warnings?
  • Have you considered edge cases?
  • Is error handling appropriate?

When reviewing code

  • Is the intention of the code clear?
  • Are there enough test cases?
  • Is it documented? Use this checklist to reduce mistakes and improve code quality.

Keywords covered in this article (related search terms)

This article will be helpful if you search for C++, lambda, lambda, anonymous function, C++11, etc.

... 996 lines not shown ... Token usage: 63706/1000000; 936294 remaining Start-Sleep -Seconds 3