🚀 MODERN ISO C++ PROGRAMLAMA DERSLERİ: BÖLÜM 7 🚀 Lambda İfadeleri, Closure Mimarısı, std::function vs Template Callable

/*
================================================================================
🚀 MODERN ISO C++ PROGRAMLAMA DERSLERİ: BÖLÜM 7 🚀
Lambda İfadeleri, Closure Mimarısı, std::function vs Template Callable
================================================================================

GİRİŞ 📌
--------------------------------------------------------------------------------
Altıncı bölümde Template Metaprogramming, SFINAE ilkesi ve C++20 Concepts /
Constraints devrimini incelemiştik.

Bu bölümde modern C++'ın esnek, modüler ve fonksiyonel kod yazımını sağlayan
**Lambda İfadelerini**, arka plandaki **Closure** sınıf yapısını, yakalama (capture)
kurallarını, C++20 ile gelen **Template Lambdaları** ve `std::function` nesnesinin
Type Erasure maliyeti ile doğrudan şablonlu çağırma arasındaki performans
farklarını ele alacağız.
*/

#include <iostream>
#include <functional>
#include <memory>
#include <string>
#include <type_traits>

// =============================================================================
// 1. LAMBDA İFADELERİ VE ARKA PLANDAKİ CLOSURE MİMARİSİ 🔍
// =============================================================================
/*
* Lambda ifadesi yazıldığında derleyici arka planda benzersiz (unique) isme sahip,
* `operator()` üye fonksiyonu yüklenmiş bir SINIF (Functor/Closure Class) üretir!
*
* Lambda Sözdizimi:
* [ capture-list ] <template-params> ( params ) mutable noexcept -> return-type { body }
*/

void demonstrate_closure_mechanics() {
int factor = 5;

// A) Yazdığımız Lambda İfadesi:
auto lambda_mult = [factor](int x) { return x * factor; };

// B) Derleyicinin Arka Planda Ürettiği Birebir Eşdeğer Closure Sınıfı:
struct __CompilerGeneratedClosure {
int m_factor; // Capture by value -> Sınıf üye değişkeni olur

explicit __CompilerGeneratedClosure(int f) : m_factor(f) {}

// Lambda operator()'ü varsayılan olarak 'const' işaretlidir!
int operator()(int x) const {
return x * m_factor;
}
};

__CompilerGeneratedClosure functor_mult(factor);

std::cout << "Lambda Sonucu: " << lambda_mult(10) << "\n";
std::cout << "Functor Sonucu: " << functor_mult(10) << "\n";
}


// =============================================================================
// 2. CAPTURE MODLARI VE `mutable` ANAHTAR KELİMESİ 🛠️
// =============================================================================

void demonstrate_captures() {
int count = 0;
auto ptr = std::make_unique<int>(100);

// 1. Capture by Value [count]: Kopyasını alır, okuma amaçlıdır.
// 2. Capture by Reference [&count]: Orijinal değişkeni değiştirmeyi sağlar.
// 3. Init-Capture / Move Capture [ptr = std::move(ptr)] (ISO C++14):
// Move-only nesneleri lambda içine taşımayı sağlar.

auto process = [count, &count, moved_ptr = std::move(ptr)]() mutable {
// `mutable`: Lambda'nın 'const' olan operator() üye fonksiyonunun
// yakalanan kopyaları (count) değiştirmesine izin verir!

// count++; // Yakalanan kopyayı artırır (dışarıyı etkilemez)
count += 10; // Reference ile yakalandığı için DIŞARIDAKİ count artar!

std::cout << " Lambda İçi -> count (ref): " << count
<< ", moved_ptr: " << *moved_ptr << "\n";
};

process();
std::cout << " Lambda Dışı -> count: " << count << "\n";
if (!ptr) {
std::cout << " 'ptr' lambda içine başarıyla taşındı (nullptr)!\n";
}
}


// =============================================================================
// 3. ISO C++20 TEMPLATE LAMBDALAR VE GENERIC SYNTAX ⚙️
// =============================================================================
/*
* C++14 ile gelen `auto` parametreli Generic Lambdalar harikadır ancak
* parametre tiplerine doğrudan erişmek veya kısıtlamak imkansızdı.
* C++20 ile açık Şablon Parametre Listesi (`[]<typename T>(...)`) eklenmiştir!
*/

void demonstrate_cpp20_template_lambdas() {
// C++20 Explicit Template Lambda
auto print_vector_element = []<typename T>(const std::vector<T>& vec) {
// T tipine doğrudan erişebiliyoruz (static_assert, type_traits vb. için)
using ElementType = T;
std::cout << " Vector Eleman Tipi Boyutu: " << sizeof(ElementType)
<< " bytes, Eleman Sayısı: " << vec.size() << "\n";
};

std::vector<int> i_vec{1, 2, 3};
std::vector<double> d_vec{1.1, 2.2};

std::cout << "⚙️ C++20 Template Lambdalar:\n";
print_vector_element(i_vec);
print_vector_element(d_vec);
}


// =============================================================================
// 4. PERFORMANCE ANALİZİ: `std::function` VS TEMPLATE CALLABLE ⚡
// =============================================================================
/*
* `std::function`: Polymorphic Function Wrapper (Tür Silme - Type Erasure)
* - Her türlü çağrılabilir yapıyı (lambda, fonksiyon göstericisi, functor) tutar.
* - PERFORMANS MALİYETİ:
* 1. Type Erasure nedeniyle sanal tablo (vtable) benzeri dolaylı çağırma (Indirect Call)
* 2. Küçük Nesne Optimizasyonunu (SBO) aşan büyük closure'lar için HEAP ALLOCATION!
* 3. Inlining (satır içi genişletme) imkanını yok eder!
*
* MİMARİ SEÇİM:
* API kütüphanelerinde esneklik gerekiyorsa `std::function`, yüksek performanslı
* döngü veya şablon mimarilerinde TEMPLATE CALLABLE tercih edilmelidir!
*/

// A) Yavaş Yöntem: std::function (Type Erasure & Overhead)
void execute_std_function(const std::function<void(int)>& func) {
func(42); // Indirect Call (Inlining İptal)
}

// B) Hızlı Yöntem: Template Callable (Zero-overhead & Fully Inlined)
template<typename Callable>
void execute_templated(Callable&& func) {
func(42); // Doğrudan çağrı (Inlining aktif!)
}

void demonstrate_performance_aspects() {
int secret = 1000;
auto my_lambda = [secret](int val) {
return val + secret;
};

// Template kullanımı: Lambda tipini tam korur, doğrudan çağrılır.
execute_templated(my_lambda);

// std::function kullanımı: Lambda tipi silinir, sarıcı nesneye dönüştürülür.
execute_std_function(my_lambda);
}


// =============================================================================
// 5. MAIN VE PROGRAM GİRİŞ NOKTASI 🚀
// =============================================================================

int main() {
std::cout << "============================================" << std::endl;
std::cout << " ISO C++17/20/23 Dersleri - Bolum 7 " << std::endl;
std::cout << "============================================" << std::endl << std::endl;

std::cout << "--- 1. Closure Mimarisi ---" << std::endl;
demonstrate_closure_mechanics();

std::cout << "\n--- 2. Capture Modları ve mutable ---" << std::endl;
demonstrate_captures();

std::cout << "\n--- 3. ISO C++20 Template Lambdalar ---" << std::endl;
demonstrate_cpp20_template_lambdas();

std::cout << "\n--- 4. Performance & Dispatch ---" << std::endl;
demonstrate_performance_aspects();

std::cout << "\n✔ Bolum 7 Kavramları Başarıyla İşlendi!" << std::endl;

return 0;
}

/*
================================================================================
BÖLÜM ÖZETİ VE GELECEK BÖLÜM 📝
--------------------------------------------------------------------------------
Bu bölümde Lambda ifadelerinin derleyici düzeyindeki Closure yapısını, capture
kurallarını, `mutable` mekanizmasını, C++20 Template Lambdaları ve `std::function`
maliyet analizini inceledik.

Gelecek Bölüm (Bölüm 8):
- Eşzamanlılık (Concurrency) & Çok İzli Programlama (Multithreading) 🧵
- `std::thread` vs ISO C++20 `std::jthread` (RAII & Auto-Join/Cancel)
- Veri Yarışı (Data Race) & `std::mutex`, `std::unique_lock`, `std::scoped_lock` (C++17)
- `std::atomic<T>` & Bellek Sipariş Modelleri (Memory Orders) ⚡
- `std::future`, `std:romise` ve `std::async` ile Asenkron Görevler
==
==============================================================================
Bölüm 7 Sonu.
================================================================================
*/

🔒 Bu içeriği görmek için giriş yapın

Giriş Yap Forum Kayıt Ol Telegram Grubumuza Katıl