[capture_list](parameters) mutable -> return_type {
    // function body
}

• Capture List (`[capture_list]`) : Lambda'nın tanımlandığı kapsamdaki değişkenlere erişimini belirler. Boş bırakılabilir (`[]`) veya virgülle ayrılmış değişkenler içerebilir. Değerle (`[var]`), referansla (`[&var]`), veya varsayılan olarak tümünü değerle (`[=]`) ya da referansla (`[&]`) yakalayabiliriz. Bu, lambdanın dış kapsamdan gelen verilere nasıl erişeceğini kontrol eden kritik bir bileşendir.
• Parametreler (`(parameters)`): Klasik bir fonksiyon gibi, lambdanın alacağı argümanları tanımlar. Parametre listesi boş olabilir `()`. C++14 ile birlikte, genel lambdalar (generic lambdas) sayesinde parametreler için `auto` anahtar kelimesi kullanılabilir hale gelmiştir, bu da lambdaların şablon fonksiyonlar gibi çalışmasına olanak tanır.
• Mutable (`mutable`): Eğer bir lambda, değerle yakaladığı değişkenleri kendi gövdesi içinde değiştirmek istiyorsa `mutable` anahtar kelimesini kullanmalıdır. Varsayılan olarak, değerle yakalanan değişkenler `const` kabul edilir.
• Dönüş Tipi (`-> return_type`): Lambdanın döndüreceği değerin tipini belirtir. Çoğu zaman derleyici dönüş tipini otomatik olarak çıkarabilir, bu yüzden bu kısım isteğe bağlıdır. Ancak karmaşık durumlarda veya belirli bir tip dönüşünü zorlamak istediğinizde açıkça belirtmek faydalı olabilir.
• Fonksiyon Gövdesi (`{ body }`): Lambdanın gerçekleştireceği işlemleri içeren kod bloğudur. Klasik bir fonksiyonun gövdesiyle aynıdır.

• Değerle Yakalama (`[var]`) : `[x]` ifadesi, `x` değişkeninin bir kopyasını lambdanın içine alır. Bu kopya üzerinde yapılan değişiklikler, orijinal `x` değişkenini etkilemez.
• Referansla Yakalama (`[&var]`) : `[&x]` ifadesi, `x` değişkenine bir referans alır. Bu sayede, lambda içinde `x` üzerinde yapılan değişiklikler orijinal `x` değişkenini etkiler.
• Varsayılan Değerle Yakalama (`[=]`) : Lambdanın gövdesinde kullanılan tüm otomatik değişkenleri (global veya statik olmayan) değerle yakalar. Bu, kodun genellikle daha güvenli olmasını sağlar çünkü dış değişkenlerin yanlışlıkla değiştirilmesi engellenir.
• Varsayılan Referansla Yakalama (`[&]`) : Lambdanın gövdesinde kullanılan tüm otomatik değişkenleri referansla yakalar. Büyük ve karmaşık veri yapılarını kopyalamaktan kaçınmak için performans açısından faydalı olabilir, ancak dış değişkenlerin yaşam sürelerine dikkat etmek gerekir.
• Karışık Yakalamalar (`[var1, &var2, =]`) : Hem belirli değişkenleri yakalayıp hem de genel bir yakalama varsayımı belirtebiliriz. Örneğin, `[=, &x, y]` ifadesi, `x`'i referansla, `y`'yi değerle yakalar ve diğer tüm kullanılan değişkenleri varsayılan olarak değerle yakalar.

"Lambda ifadeleri, C++'a getirdikleri anonim fonksiyonlar ve esnek yakalama mekanizmaları ile modern programlama paradigmalarına yeni bir soluk getirmiştir." - Programlama Uzmanı

Genişletmek için tıkla ...

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

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

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

    // Yaşa göre küçükten büyüğe sıralama
    std::sort(people.begin(), people.end(), [](const Person& a, const Person& b) {
        return a.age < b.age;
    });

    std::cout << "Yaşa göre sıralanmış kişiler:" << std::endl;
    for (const auto& p : people) {
        std::cout << p.name << " (" << p.age << ")" << std::endl;
    }

    std::cout << "\n------------------\n";

    // Adı 'B' ile başlayanları bulma
    auto it = std::find_if(people.begin(), people.end(), [](const Person& p) {
        return p.name[0] == 'B';
    });

    if (it != people.end()) {
        std::cout << "Adı 'B' ile başlayan ilk kişi: " << it->name << std::endl;
    } else {
        std::cout << "Adı 'B' ile başlayan kimse bulunamadı." << std::endl;
    }

    std::cout << "\n------------------\n";

    // Belirli bir yaşın üzerindekileri sayma (yakalama ile)
    int minAge = 28;
    int count = 0;
    std::for_each(people.begin(), people.end(), [&](const Person& p) {
        if (p.age > minAge) {
            count++; // 'count' referansla yakalandığı için dışarıdaki değişkeni değiştirir
        }
    });
    std::cout << minAge << " yaşından büyük kişi sayısı: " << count << std::endl;

    return 0;
}

#include <iostream>
#include <vector>
#include <functional> // std::function için

// Basit bir olay yöneticisi sınıfı
class EventManager {
public:
    using Callback = std::function<void(int)>;

    void addListener(Callback cb) {
        listeners.push_back(cb);
    }

    void triggerEvent(int eventData) {
        for (const auto& cb : listeners) {
            cb(eventData);
        }
    }

private:
    std::vector<Callback> listeners;
};

int main() {
    EventManager em;
    int clickCount = 0;

    // Lambda kullanarak bir dinleyici ekle
    // clickCount'u yakala ve mutable yap, böylece içinde değiştirebiliriz
    em.addListener([&](int data) {
        std::cout << "Olay tetiklendi! Veri: " << data << std::endl;
        clickCount++; // clickCount'u artır
        std::cout << "Toplam tıklama sayısı: " << clickCount << std::endl;
    });

    em.triggerEvent(10); // Olayı tetikle
    em.triggerEvent(20);
    em.triggerEvent(30);

    return 0;
}

• Genel Lambdalar (Generic Lambdas - C++14): Parametre listesinde `auto` anahtar kelimesi kullanılarak, aynı bir fonksiyon şablonu gibi birden fazla tip için çalışabilen lambdalar tanımlanabilir.
  
  Kod:

  auto multiply = [](auto a, auto b) {
      return a * b;
  };
  
  std::cout << "5 * 3 = " << multiply(5, 3) << std::endl;
  std::cout << "2.5 * 4.0 = " << multiply(2.5, 4.0) << std::endl;

• Init Capture (C++14): Yakalama listesinde yeni değişkenler tanımlayarak veya mevcut değişkenleri farklı isimlerle yakalayarak, lambda'nın yaşam süresi boyunca sahip olacağı durumları daha esnek bir şekilde yönetmeyi sağlar.
  
  Kod:

  int x = 10;
  auto lambda_init_capture = [y = x * 2]() {
      std::cout << "y (init capture): " << y << std::endl;
  };
  lambda_init_capture(); // Çıktı: y (init capture): 20

• `constexpr` Lambdalar (C++17): C++17 ile birlikte, basit lambdalar derleme zamanında değerlendirilebilen `constexpr` olarak işaretlenebilir, bu da daha fazla performansa olanak tanır.
• `noexcept` Lambdalar (C++17): Lambdaların istisna atmayacağını belirtmek için `noexcept` kullanılabilir, bu da derleyicinin optimizasyon yapmasına yardımcı olur.

• Okunabilirlik ve Yerellik: Fonksiyonun tanımlandığı yerde kullanılması, kodun daha okunabilir ve anlaşılır olmasını sağlar. İlgili mantık, ihtiyaç duyulduğu yere yakın durur.
• Kısalık (Conciseness): Özellikle kısa, tek kullanımlık fonksiyonlar için ayrı bir fonksiyon veya sınıf tanımlama ihtiyacını ortadan kaldırır. Bu, boilerplate kodu azaltır.
• Kapsam Erişimi (Scope Access): Yakalama listesi sayesinde, lambdanın tanımlandığı yerdeki değişkenlere kolayca erişim sağlanır.
• Performans: Derleyici, lambda'ları genellikle inlined edebilir veya doğrudan çağrı mekanizmalarıyla optimize edebilir, bu da fonksiyon işaretçileri veya `std::function` kullanımına kıyasla potansiyel performans avantajları sunar.
• Esneklik: Standart algoritmalarla ve callback mekanizmalarıyla kusursuz entegrasyon.

• Karmaşıklık: Çok büyük veya karmaşık lambda'lar, özellikle karmaşık yakalama listeleri içeriyorsa, okunması ve hata ayıklanması zorlaşabilir. Bu tür durumlarda geleneksel fonksiyonları veya sınıf yöntemlerini tercih etmek daha iyi olabilir.
• Yaşam Süresi Sorunları: Referansla yakalama (`[&]`) kullanıldığında, yakalanan değişkenlerin lambdanın yaşam süresinden daha kısa süreli olmaması kritiktir. Aksi takdirde, askıda kalmış referans (dangling reference) sorunları ortaya çıkabilir.
• Aşırı Kullanım: Her küçük işlem için lambda kullanmak, kodun mantıksal yapısını bozabilir ve genel okunabilirliğini azaltabilir. Dengeli bir kullanım önemlidir.