KURUMSAL EĞİTİM, C PLUS PLUS İLE GELECEĞİ KODLAYIN

İLERİ DÜZEY C++ GELİŞTİRME EĞİTİMİ — MODERN C++11/14/17/20

C++, dünya genelinde işletim sistemlerinin, oyun motorlarının (Unreal Engine), gömülü sistemlerin, finansal algoritmik trading platformlarının ve yüksek performanslı veritabanlarının çoğunun temel taşı. Python veya Go gibi diller yüksek soyutlama sunarken C++, donanıma yakın kontrol ile soyutlamayı birleştiren ve derleyici optimizasyonlarıyla C düzeyinde hız elde eden tek ana akım dil konumunu sürdürüyor. Stack Overflow 2024 anketine göre C++ profesyoneller arasında en çok tercih edilen dillerden biri olmaya devam ediyor ve sistem programlama, oyun geliştirme, gömülü sistem ve HFT pozisyonlarında birincil dil şartı.

Bu eğitim "ileri düzey" başlığını hak eden bir içerikle sunulur: Temel sözdizimi kısa bir giriş modülünde geçildikten sonra odak, C++11'den C++20'ye kadar modern standartların getirdiği dönüşümlere kayar. Move semantics, smart pointer'lar, RAII, variadic template, constexpr, concept, coroutine, structured binding, ranges ve std::execution gibi konular; "neden bu özellik eklendi" sorusu etrafında motivasyon → problem → çözüm → trade-off yapısıyla öğretilir. Soyut tanımlarla değil, gerçek üretim kodundan örneklerle.

On iki modüle yayılan program; C++ temel yapılardan OOP derinliklerine, şablon programlama ve STL'den bellek yönetimi ve RAII'ye, modern C++ özelliklerinden çoklu iş parçacığı (multithreading) ve concurrency'e, dosya I/O ve akış yönetiminden performans analizi ve derleme zamanı optimizasyonuna kadar uzanır. Her modülde gerçek dünya senaryo analizi ve kod incelemesi yapılır.

Eğitim; sistem yazılımı, oyun geliştirme, gömülü sistem ve algoritmik trading alanlarında C++ kullanmak isteyen yazılım geliştiriciler, C veya Java/Python bilgisiyle C++'a geçmek isteyen mühendisler ve modern C++ standartlarını ( C++17/20) derinlemesine öğrenmek isteyen deneyimli C++ kullanıcıları için tasarlanmıştır. Ön koşul: herhangi bir dilde temel programlama deneyimi.

EĞİTİM HEDEFİ

Bu eğitimin temel hedefi, katılımcıların modern C++ (C++11 ila C++20) ekosistemini üretim kalitesinde kod yazabilecek düzeyde kavramasını sağlamaktır. Eğitim sonunda katılımcılar; C++ derleme modelini (preprocessing → compilation → linking → loading) ve tanımsız davranış (undefined behavior) kavramını anlar. Temel veri türleri, değer kategorileri (lvalue/rvalue/xvalue/prvalue/glvalue) ve type system'i kavrar; static_cast, dynamic_cast, const_cast ve reinterpret_cast arasındaki güvenlik sınırlarını bilir. OOP ilkelerini — kapsülleme, kalıtım (public/protected/private), çok biçimlilik (virtual/override/final), soyut sınıf (pure virtual), CRTP ve interface pattern — C++'a özgü inceliklerle uygular. Constructor ve destructor semantiğini, Rule of Zero/Three/Five ilkesini, copy constructor ve copy assignment, move constructor ve move assignment operatörlerini doğru yazar. RAII ile kaynak yönetimini (dosya, mutex, ağ soketi) güvenli hale getirir; unique_ptr, shared_ptr, weak_ptr ile raw pointer kullanımını ortadan kaldırır; bellek sızıntısını Valgrind ve AddressSanitizer ile tespit eder. Fonksiyon ve sınıf şablonlarını (template), kısmi uzmanlaşmayı (partial specialization), variadic template ve fold expression'ı, SFINAE mantığını ve C++20 Concepts'i yazar. Lambda ifadelerini (capture by value/reference, mutable, generic lambda) ve std::function ile std::bind'i kullanır; modern C++ algoritmaları ile ranges kütüphanesini ve views pipeline'ını uygular. std::thread, std::mutex, std::lock_guard, std::unique_lock, std::condition_variable, std::atomic ile thread-safe veri yapısı inşa eder; std::async, std::future ve std::promise ile asenkron hesaplama yönetir; deadlock, race condition ve false sharing'i tespit eder. Derleme süresi hesaplama için constexpr ve consteval kullanır; yapısal bağlama (structured binding), if constexpr, std::variant, std::optional ve std::any ile tip güvenli kod yazar; std::coroutine temeli ile asenkron iş akışı kurar. STL container'larını (vector, deque, list, forward_list, map, unordered_map, set, unordered_set, stack, queue, priority_queue) doğru seçim kriteriyle kullanır; custom allocator yazar; cache-friendly data layout tasarlar ve profil çıkarma (perf, gprof, VTune) ile hotspot tespit eder.

EĞİTİM İÇERİĞİ

MODÜL 1: C++ TEMELLERİ VE DERLEME MODELİ

• C++ Tarihsel Evrimi ve Standart Versiyonları: C++98/03'ten C++11'e paradigma değişimi; C++14 (generic lambda, constexpr genişletme), C++17 (if constexpr, structured binding, std::filesystem, std::variant), C++20 (Concepts, Ranges, Coroutines, Modules) — her standardın "neden" sorusu; ISO standart süreci ve compiler desteği tablosu (GCC, Clang, MSVC).
• Derleme Modeli Derinlemesine: Önişleme (preprocessor) → derleme (compilation) → bağlama (linking) → yükleme (loading); translation unit ve ODR (One Definition Rule); başlık (header) ve kaynak (.cpp) dosyası ayrımı; forward declaration ile bağımlılık kırma; object file formatı (ELF, PE, Mach-O); static library (.a/.lib) vs shared library (.so/.dll); link-time optimization (LTO).
• Temel Tip Sistemi ve Değer Kategorileri: Fundamental tipler ve platform bağımlılığı (int boyutu); <cstdint> ile kesin boyutlu tipler (int32_t, uint64_t); const correctness; constexpr vs const farkı; değer kategorileri — lvalue (adres alınabilir kalıcı), rvalue (geçici), xvalue (taşınabilir), prvalue, glvalue; auto ve decltype ile tip çıkarımı; uniform initialization ({}) ve narrowing conversion.
• Kapsam, Ömür ve Tanımsız Davranış: Statik, otomatik ve dinamik depolama süresi; kapsam (scope) kuralları ve name hiding; tanımsız davranış (UB) — neden derleyici optimizasyonlarını kırar; UBSan (Undefined Behavior Sanitizer) ile UB tespiti; Sanitizer araçları (ASan, TSan, MSan, UBSan) ve CI'ya entegrasyonu.
• Hands-on Lab: CMake ile çok dosyalı C++ projesi yapılandırma; GCC hata ve uyarı flag'lerini (-Wall -Wextra -Wpedantic -fsanitize) etkinleştirme; preprocessor makro ile platform bağımlı kod; LTO etkisini benchmark ile ölçme.

MODÜL 2: OOP DERİNLİKLERİ — SINIFLAR, KALITIM VE POLİMORFİZM

• Sınıf Tasarımı ve Kapsülleme: public/protected/private erişim belirleyicileri; member function, const member function ve mutable; static member ve static member function; friend function ve friend class; nested class; Pimpl Idiom (pointer to implementation) ile ABI stability; operator overloading — hangi operatörler neden overload edilir, hangileri edilmez.
• Constructor ve Destructor Semantiği: Default, parametreli, copy ve move constructor; copy assignment ve move assignment operatörü; Rule of Zero (STL kullan, hiç yazma), Rule of Three (C++03), Rule of Five (C++11); member initializer list vs assignment in constructor body; delegating constructor; virtual destructor zorunluluğu ve nedeni; explicit keyword ile implicit conversion engelleme.
• Kalıtım ve Çok Biçimlilik: public/protected/private kalıtım semantiği; virtual function ve vtable mekanizması; override ve final keyword'leri; pure virtual function ve abstract class; çoklu kalıtım (multiple inheritance) ve diamond problem; sanal kalıtım (virtual inheritance); CRTP (Curiously Recurring Template Pattern) ile derleme zamanı polimorfizmi; interface pattern (tamamen soyut sınıf).
• Nesne Modeli ve Bellek Düzeni: sizeof(class) ve padding; alignment ve alignas; vtable pointer ve nesne boyutuna etkisi; empty base optimization (EBO); data member offset ve offsetof; bit field tasarımı; union ve anonymous union; std::bit_cast ile güvenli tip punning.
• Hands-on Lab: Şekil hiyerarşisi (Shape → Circle, Rectangle, Triangle) — pure virtual alan ve çevre hesaplama; CRTP ile derleme zamanı polimorfizmi ve vtable karşılaştırması; Pimpl Idiom ile bağımlılık-serbest API tasarımı; Rule of Five uygulayan dinamik dizi sınıfı.

MODÜL 3: BELLEK YÖNETİMİ, RAII VE SMART POINTER'LAR

• Stack ve Heap Bellek Modeli: Stack frame ve call stack; heap fragmentation; new/delete ve new[]/delete[] asimetri kuralı; placement new ile önceden ayrılmış bellekte nesne oluşturma; operator new/delete overriding; aligned_alloc; bellek sızıntısı tespiti — Valgrind memcheck ve AddressSanitizer; dangling pointer ve use-after-free; double free.
• RAII — Kaynak Yönetiminin Temeli: "Kaynak edinimi = başlatma" prensibi; RAII ile dosya, mutex, ağ soketi, veritabanı bağlantısı yönetimi; exception safety — basic, strong ve no-throw garantileri; scope guard pattern; std::lock_guard ve std::unique_lock RAII mutex yönetimi örnekleri; RAII olmadan exception-safe kod yazmanın imkânsızlığı.
• Smart Pointer'lar Derinlemesine: unique_ptr — tek sahiplik, move-only, custom deleter, std::make_unique; shared_ptr — reference counting, atomic referans sayacı, control block yapısı; weak_ptr — döngüsel referansı kırma, lock() ile güvenli yükseltme; shared_ptr'nin performans maliyeti (iki işaretçi + atomic); enable_shared_from_this; raw pointer kullanımının kaldığı meşru senaryolar (gözlemci/gözlemlenen, performans-kritik döngüler).
• Custom Allocator ve Bellek Havuzu: std::allocator arayüzü; pool allocator ile heap parçalanmasını önleme; arena allocator ile belirli bir yaşam süresine sahip nesneler; std::pmr (polymorphic memory resource) — C++17 monotonic_buffer_resource, pool_resource; cache-friendly allocation stratejisi.
• Hands-on Lab: Raw pointer kullanan eski kodu smart pointer'a dönüştürme; döngüsel referans tuzağını weak_ptr ile çözme; Valgrind ile bellek sızıntısı bulma ve düzeltme; basit pool allocator implementasyonu ve benchmarkı.

MODÜL 4: MOVE SEMANTİCS, KOPYALAMA VE DE TAŞIMA

• Değer Kategorileri ve Referans Türleri: lvalue reference (&) ve rvalue reference (&&) semantiği; const lvalue reference ile geçici nesne ömrü uzatma; forwarding reference (T&&) ve universal reference ayrımı; std::move — taşıma tetikleyicisi; std::forward — mükemmel yönlendirme (perfect forwarding); move constructor'dan sonra "moved-from" nesnenin durumu.
• Move Semantics Performans Etkisi: std::string, std::vector, std::unique_ptr taşıma maliyeti — O(1) vs O(N) kopya; Return Value Optimization (RVO) ve Named RVO (NRVO); C++17 guaranteed copy elision; move-only tipler (unique_ptr, std::thread, std::future) ve algoritma entegrasyonu; noexcept specifier ile taşıma operatörlerinin önemi (std::vector reallocation).
• Copy-and-Swap Idiom: Exception-safe assignment operatörü yazma; swap ile strong exception guarantee; std::swap özelleştirmesi ve ADL (Argument-Dependent Lookup); move assignment'ta self-assignment güvenliği; copy-on-write (COW) ve modern C++'da neden terk edildiği.
• Hands-on Lab: Büyük dizi tutan sınıf — kopya vs taşıma benchmark; std::vector'de emplace_back vs push_back karşılaştırması; perfect forwarding ile factory fonksiyonu; noexcept yok iken std::vector'ün kopyaya düşmesini gözlemleme.

MODÜL 5: ŞABLON PROGRAMLAMA VE GENERİK TASARIM

• Fonksiyon ve Sınıf Şablonları: template<typename T> ve template<class T> farkı; şablon argüman çıkarımı (TAD); explicit template instantiation vs implicit; şablon fonksiyonda overload resolution; sınıf şablonu üye fonksiyonu dışında tanımlama; şablon alias (using); variable template (C++14).
• Uzmanlaşma ve Kısmi Uzmanlaşma: Full template specialization — özel tip için farklı implementasyon; partial template specialization — pointer tiplerini yakalama, N boyutlu dizi; std::is_same, std::enable_if ve SFINAE (Substitution Failure Is Not An Error) ile koşullu şablon etkinleştirme; tag dispatch ile tür tabanlı derleme zamanı dallanma.
• Variadic Template ve Fold Expression: Template parameter pack (...Args); sizeof...(Args) ile argüman sayısı; recursive variadic template expansion; C++17 fold expression — unary fold ve binary fold; variadic function template ile std::tuple tabanlı heterogen koleksiyon; tuple'ı diziye yansıtma (index_sequence).
• C++20 Concepts ve Kısıtlamalar: requires expression ve requires clause; concept tanımlama; abbreviated function template (auto parameter); standart concept'ler (std::integral, std::floating_point, std::ranges::range); concept ile SFINAE karşılaştırması — daha iyi hata mesajları; constrained auto; concept composition (&&, ||).
• Hands-on Lab: Tip güvenli heterojen tuple — variadic template ile; std::vector sadece arithmetic tip kabul eden Concepts kısıtlı fonksiyon; enable_if vs Concepts aynı problemi çözme karşılaştırması; derleme zamanı faktöriyel ve Fibonacci — template metaprogramming.

MODÜL 6: LAMBDA, FUNCTIONAL PROGRAMLAMA VE STL ALGORİTMALARI

• Lambda İfadeleri Derinlemesine: Lambda sözdizimi — capture list, parametre, return tipi, body; değer ile yakalama [=], referans ile [&], karma [x, &y], hiç []; mutable lambda — yakalanan kopya üzerinde değişiklik; generic lambda (C++14) — auto parametre; variadic generic lambda; immediately invoked lambda (IIFE); lambda ve closure türü — her lambda unique tip.
• std::function, std::bind ve Callable Kavramı: Callable konsepti — fonksiyon pointer, functor, lambda, member function pointer; std::function ile type erasure maliyeti; std::bind ile argüman bağlama ve placeholder; std::invoke ile uniform callable çağrısı; std::function yerine template ile sıfır maliyet callable; std::mem_fn ile member function wrapper.
• STL Algoritmaları Üretim Kullanımı: <algorithm> koleksiyonu — sort, stable_sort, partial_sort, nth_element; find, find_if, find_first_of; transform, for_each, accumulate, reduce; remove_if + erase (erase-remove idiom); rotate, partition, unique; string_view ile zero-copy string işleme; <numeric> — iota, inner_product, partial_sum.
• C++20 Ranges ve Views: Range kavramı ve range adaptörü; views::filter, views::transform, views::take, views::drop, views::zip, views::join; lazy evaluation — view pipeline'ı yalnızca iterasyon sırasında çalışır; std::ranges::sort, std::ranges::find_if; range projection; sentinels ve views::counted; Ranges ile algoritma bileşimi.
• Hands-on Lab: Çok kriterli öğrenci sıralama pipeline'ı — ranges::sort + projection; istatistik fonksiyonları — std::accumulate ile ortalama ve standart sapma; erase-remove ile filtre; generic event dispatcher — std::function + unordered_map; ranges views pipeline ile veri dönüşümü.

MODÜL 7: MODERN C++ ÖZELLİKLERİ — C++17 VE C++20

• C++17 Yapısal Bağlama ve if constexpr: Structured binding ile tuple, pair, struct ve map elemanlarına isimli erişim; if constexpr ile derleme zamanı dal seçimi ve gereksiz kod üretimini engelleme; init-statement in if/switch; inline variable; fold expression (C++17); std::string_view — zero-copy string referansı ve güvenli kullanım kuralları.
• std::variant, std::optional ve std::any: std::variant — tip güvenli union, std::visit ve visitor pattern, monostate; std::optional — "değer yok" durumunu null pointer olmadan temsil etme, value_or, and_then (C++23); std::any — çalışma zamanı tip silme, any_cast; std::expected (C++23) — hata değerini exception olmadan döndürme temeli.
• std::filesystem ve <chrono> Modernizasyonu: std::filesystem::path ile platform bağımsız yol işleme; directory_iterator ve recursive_directory_iterator; dosya durumu sorguları (is_regular_file, exists, file_size); copy, rename, remove; std::chrono — duration, time_point, clock (system_clock, steady_clock, high_resolution_clock); std::format (C++20) ile güvenli ve performanslı string biçimlendirme.
• C++20 Coroutine Temelleri: Coroutine motivasyonu — asenkron kodun senkron gibi yazılması; co_await, co_yield, co_return anahtar kelimeleri; promise_type ve coroutine_handle mekanizması; generator pattern (co_yield ile lazy sequence); asenkron I/O coroutine tasarım örüntüsü; coroutine vs thread maliyet karşılaştırması.
• Hands-on Lab: std::variant ve std::visit ile AST (Abstract Syntax Tree) node tipleri; std::optional ile arayan fonksiyonun başarısızlığı null pointer döndürmeden ifade etmesi; std::filesystem ile dizin ağacı listeleme ve boyut hesaplama; basit generator coroutine ile Fibonacci akışı.

MODÜL 8: ÇOK İŞ PARÇACIĞI VE EŞ ZAMANLILIK (CONCURRENCY)

• std::thread ve Thread Yönetimi: std::thread — oluşturma, join, detach; thread ID ve hardware_concurrency; thread local storage (thread_local); std::jthread (C++20) — otomatik join ve stop_token; POSIX thread (pthread) ile karşılaştırma; stack boyutu ve thread oluşturma maliyeti; thread pool tasarımı.
• Mutex ve Senkronizasyon Primitifleri: std::mutex — lock/unlock; std::recursive_mutex; std::timed_mutex; RAII ile güvenli kilitleme — std::lock_guard, std::unique_lock, std::scoped_lock (C++17); std::shared_mutex — reader-writer lock; std::condition_variable — wait, notify_one, notify_all; spurious wakeup ve predikatlı wait; deadlock — tespit (ThreadSanitizer), önleme (lock ordering, std::lock).
• std::atomic ve Lock-Free Programlama: std::atomic<T> — atomic operasyonlar ve memory order (relaxed, acquire, release, acq_rel, seq_cst); CAS (compare_and_swap) ile lock-free queue tasarımı; false sharing ve cache line hizalama (alignas(64)); std::memory_order seçim kriterleri; lock-free vs lock-based trade-off.
• std::async, std::future ve std::promise: std::async ile asenkron görev başlatma (launch::async vs launch::deferred); std::future::get ile sonucu bekleme; std::promise ile üretici-tüketici kanalı; std::packaged_task ile callable'ı future'a sarma; std::shared_future ile çoklu alıcı; exception propagation through future.
• Hands-on Lab: Producer-consumer kuyruğu — mutex + condition_variable; ThreadSanitizer ile race condition tespiti; std::async ile paralel merge sort ve speedup ölçümü; atomic counter ile lock-free istatistik güncellemesi; thread pool implementasyonu ve görev kuyruğu.

MODÜL 9: STL CONTAINER'LAR VE PERFORMANS OPTİMİZASYONU

• STL Container Seçim Rehberi: Sequence containers — vector (cache-friendly, random access), deque (çift uçlu), list (çift bağlı, splice), forward_list; Ordered associative — map/multimap (kırmızı-siyah ağaç, O(log n)); Unordered associative — unordered_map (hash table, O(1) amortize); Container adapter — stack, queue, priority_queue; Container seçim matrisi: erişim, ekleme, silme ve bellek kullanımı.
• Yineleyiciler ve Iterator Kategorileri: Input, output, forward, bidirectional, random-access, contiguous iterator; iterator_traits ile generic algoritma; range-based for döngüsü ve begin/end özelleştirmesi; const_iterator ve cbegin/cend; reverse_iterator; std::next, std::prev, std::advance, std::distance; custom iterator tanımlama.
• Cache Dostu Veri Yapıları: Cache hierarchy ve locality of reference; AoS (Array of Structures) vs SoA (Structure of Arrays); std::vector<std::unique_ptr> yerine std::vector<T> tercih çerçevesi; small buffer optimization (SBO) — std::string, std::any implementasyonu; flat_map ve flat_set (sorted vector) ile cache performansı; alignment ve padding optimizasyonu.
• Profil Çıkarma ve Benchmarking: Google Benchmark ile mikro benchmark; perf stat ve perf record ile CPU sayaç analizi; Valgrind callgrind ile instruction profiling; Intel VTune Profiler; gprof; hotspot tespiti — %80-20 kuralı; SIMD (SSE, AVX) auto-vectorization ve derleyici raporu (-fopt-info-vec); link-time optimization (LTO) ve profile-guided optimization (PGO).
• Hands-on Lab: std::map vs std::unordered_map lookup benchmark; AoS vs SoA cache miss karşılaştırması (perf stat cache-misses); Google Benchmark ile string concat yöntemleri karşılaştırması; custom hash fonksiyonu ile unordered_map collision azaltma.

MODÜL 10: HATA YÖNETİMİ VE EXCEPTION SAFETY

• Exception Mekanizması Detaylı: throw, try-catch-finally (C++'da finally yok, RAII ile karşılanır); exception spec — noexcept ve noexcept(expr); std::terminate ve std::unexpected; exception hierarchy — std::exception, std::runtime_error, std::logic_error, std::bad_alloc, std::bad_cast; özel exception sınıfı tasarımı; exception header'da what() yerine override.
• Exception Safety Garantileri: No-throw (noexcept) — en güçlü garanti, destructor ve swap için zorunlu; Strong exception safety — ya tamamen başarılı ya da hiç değişiklik yok; Basic safety — invariantlar bozulmaz; exception unsafe — hiçbir garanti yok; copy-and-swap ile strong guarantee; transaction log ile strong guarantee (database pattern).
• Modern Hata Yönetimi Yaklaşımları: Exception'dan kaçınma nedenleri (gömülü sistem, HFT, oyun); std::error_code ve std::error_category ile hata kod sistemi; Result/Expected tip ile fonksiyonun başarısızlığını dönüş değerinde ifade etme; std::expected (C++23); error propagation zincirleri; logging ve structured error reporting.
• Hands-on Lab: RAII ile exception güvenli dosya işleme — akış açık kalırsa destructor kapatır; copy-and-swap ile strong guarantee sağlayan generic Swap implementasyonu; error_code ile hata kodlu API tasarımı; custom exception hiyerarşisi ve catch order kuralları.

MODÜL 11: DOSYA I/O, AKIŞ YÖNETİMİ VE SERİALİZASYON

• C++ Akış (Stream) Sistemi: iostream hiyerarşisi — ios_base, basic_ios, basic_istream, basic_ostream, basic_iostream; cin/cout/cerr/clog ve stdout sync ile performans; format manipülatörleri (setw, setprecision, fixed, hex, boolalpha); sstream ile in-memory string stream; getline ve ws manipülatörü; akış flag'leri ve durum kontrolü (fail, eof, bad).
• Dosya Akışları ve İkili Dosya: ifstream/ofstream/fstream; open mode (in, out, app, binary, trunc, ate); seekg/seekp ve tellg/tellp ile random access; ikili dosya okuma/yazma — read/write ile ham bayt; struct'ı doğrudan dosyaya serileştirme ve byte order (endianness) sorunu; memory-mapped file (mmap) ile büyük dosya işleme.
• Serializasyon ve Format Kütüphaneleri: JSON serializasyonu — nlohmann/json ve rapidjson karşılaştırması; Protocol Buffers ile ikili serializasyon ve IDL; MessagePack ile kompakt format; custom binary protocol tasarımı; std::format (C++20) ile type-safe string biçimlendirme; {fmt} kütüphanesi.
• Hands-on Lab: Öğrenci kaydı yapısını ikili dosyaya yazma ve random-access okuma; JSON serializasyonu — nlohmann/json ile nesne kaydetme ve yükleme; in-memory stream ile unit test'te I/O simülasyonu; büyük log dosyasını memory-mapped file ile satır satır işleme.

MODÜL 12: KAPSAMLİ PROJE VE GERÇEK DÜNYA UYGULAMALARI

• Mimari Tasarım ve Kod Organizasyonu: Büyük C++ projelerinde modüler mimari; C++20 modules ile başlık dosyası sorunlarını çözme; namespace tasarımı ve inline namespace versiyonlama; forward declaration stratejisi ve derleme süresi minimizasyonu; CMake target-based yapılandırma (add_library, target_include_directories, target_link_libraries); CPack ve CPM ile bağımlılık yönetimi.
• Test ve Kalite Güvencesi: Google Test (gtest) ile unit test; Google Mock ile mock object; test-driven development (TDD) pratiği; CTest ile test entegrasyonu; kod kapsamı analizi (gcov, lcov); static analysis — clang-tidy ve cppcheck; code review checklist — undefined behavior, exception safety, thread safety, resource leak.
• Gerçek Dünya Senaryo Analizleri: Sistem programlama — basit bir process manager implementasyonu (fork, exec, waitpid wrapping); oyun geliştirme — bileşen-tabanlı varlık sistemi (Entity-Component-System) tasarımı; algoritmik trading — lock-free order book veri yapısı; gömülü sistem — static memory allocation ile dynamic allocation'ı ortadan kaldırma; network programlama — non-blocking socket ve asenkron I/O temeli.
• Modern C++ Idiom ve Best Practices: Almost Always Auto (AAA) kuralı; prefer const-ref over copy; return-value optimization ile gereksiz kopyadan kaçınma; niebloid ve customization point object (CPO); erase-remove idiom vs std::erase (C++20); C++ Core Guidelines — GSL ve enforcement ile statik analiz; sanitizer tabanlı CI pipeline tasarımı.
• Kapsamlı Proje Sunumu: Katılımcılar seçtikleri bir C++ projesi (oyun bileşeni, sistem aracı, algoritmik yapı veya ağ servisi) geliştirip sunar; değerlendirme kriterleri: doğruluk, memory safety, thread safety, exception safety, test kapsamı ve benchmark sonuçları.

EĞİTİM YÖNTEMİ

• Motivasyon → Problem → Çözüm → Trade-off Yapısı: Her C++ özelliği önce motivasyonuyla (neden eklendi?) öğretilir, ardından çözdüğü somut problem gösterilir, çözüm implementasyonu yapılır ve kabul edilen trade-off'lar (performans, karmaşıklık, okunabilirlik) tartışılır. Bu yapı, özelliği soyut değil uygulanabilir şekilde kavramayı sağlar.
• Gerçek Üretim Kodu İncelemesi: Her modülde gerçek açık kaynak C++ projesinden (LLVM, Chromium, SQLite, folly, Abseil) seçilmiş kod parçaları incelenir. Katılımcılar "neden böyle yazılmış?" sorusunu yanıtlayarak mimari kararların arkasındaki mühendislik düşüncesini kavrar.
• Sanitizer Tabanlı Hata Tespit Laboratuvarları: AddressSanitizer (bellek sızıntısı, buffer overflow), ThreadSanitizer (race condition, deadlock), UBSan (tanımsız davranış), Valgrind ile silahlandırılmış debug ortamında kasıtlı hata barındıran kod analiz edilir ve düzeltilir. Bu yaklaşım, gerçek üretim ortamında karşılaşılan hata kategorilerini erken tanımlama becerisi kazandırır.
• Benchmark Odaklı Performans Bilinç Geliştirme: Google Benchmark ve perf ile her performans iddiası ölçülür. "Bu daha hızlı" yerine "bu benchmark'ta %X daha hızlı, bu nedenle" dili kullanılır. Katılımcılar naïve optimizasyon ve gerçek optimizasyon arasındaki farkı sayısal olarak gözlemler.
• Kapsamlı Proje ve Kod İncelemesi: Katılımcılar eğitim boyunca kümülatif bir proje geliştirir. Her modülde projeye yeni C++ özellikleri ve katmanlar eklenir. Dönem sonunda gerçek bir kod inceleme (code review) oturumunda tüm katılımcıların kod incelemeleri paylaşılır ve C++ Core Guidelines çerçevesinde değerlendirilir.

HEDEF KİTLE

C VEYA C++ TEMEL BİLGİYLE GELİŞMEK İSTEYEN GELİŞTİRİCİLER

• C veya eski tarz C++98/03 bilen, modern C++ (C++11 ila C++20) standartlarının getirdiği move semantics, smart pointer, template, lambda, ranges ve concurrency özelliklerini üretim düzeyinde kavramak ve "eski C++ alışkanlıklarını" bırakmak isteyen yazılım geliştiriciler.

SİSTEM YAZILIMI VE GÖMÜLİ SİSTEM MÜHENDİSLERİ

• İşletim sistemi bileşeni, aygıt sürücüsü, firmware veya real-time sistem geliştiren mühendisler; dinamik bellek tahsisinden kaçınan static memory pattern, custom allocator, noexcept disiplini ve lock-free veri yapılarıyla kaynak-kısıtlı ortamlarda güvenli ve öngörülebilir C++ kodu yazmak isteyen sistem programcıları.

OYUN GELİŞTİRİCİLER VE GRAFIK PROGRAMCILAR

• Unreal Engine, Unity natif eklenti veya özel oyun motoru geliştiren oyun programcıları; Entity-Component-System (ECS) mimarisi, data-oriented design, cache-friendly bellek düzeni, SIMD optimizasyonu ve çok iş parçacıklı görev sistemi kurmak isteyen grafik ve oyun mühendisleri.

ALGORİTMİK TRADİNG VE YÜK SEVİYELİ SİSTEM GELİŞTİRİCİLER

• Düşük gecikme (low-latency) uygulamaları — order book, FIX protocol engine, market data feed handler — geliştiren HFT yazılımcılar; lock-free kuyruk, memory-mapped file, kernel bypass (DPDK/RDMA) ve CPU pinning gibi nanosaniye düzeyinde optimizasyon tekniklerini C++'da uygulamak isteyen geliştiriciler.

PYTHON/JAVA'DAN C++'A GEÇİŞ YAPAN YAZILIMCILAR

• Python veya Java'dan gelen, garbage collection yerine RAII ile bellek yönetimini, dynamic dispatch yerine compile-time polimorfizmi ve implicit type coercion yerine strict type system'i kavramak isteyen; C++'ın performans avantajını kendi projelerine taşımayı hedefleyen yazılım mühendisleri.

KATILIMCILARDAN BEKLENTİLERİMİZ

• Herhangi Bir Dilde Programlama Deneyimi: C, Python, Java, C# veya Go'da değişken, döngü, koşul ve fonksiyon yazmış olmak yeterlidir. C++ sıfırdan öğrencilerini hedefleyen bir eğitim değildir; en azından "programlama ne demek" sorusunu deneyimle yanıtlamış olmak beklenir.
• Derleyici ve Terminal Temel Kullanımı: GCC veya Clang ile komut satırında derleme yapabilmek (g++ -o output main.cpp), temel hata mesajlarını okuyabilmek ve bir text editor veya IDE (VS Code, CLion, Visual Studio) kurmuş olmak. CMake konfigürasyonu sıfırdan öğretilir.
• Temel Veri Yapısı ve Algoritma Kavramı: Dizi, liste, yığın ve kuyruk ne işe yarar bilmek; O(n) ve O(log n) karmaşıklık notasyonunu kavramak. İleri veri yapıları ve algoritmalar eğitimde gerekli düzeyde C++ bağlamında ele alınır.
• Tanımsız Davranışa Hazırlık: C++'ın bellek güvensizliği, tanımsız davranış ve segfault gibi kavramlara karşı zihinsel hazırlık. C++'da "neden çalışmıyor?" sorusunun yanıtı her zaman mantıklı değildir; bu belirsizlikle sabırla çalışmaya istekli olmak eğitimin temel taleplerinden biridir.
• Sürekli Pratik Motivasyonu: C++'ı okumayla öğrenmek mümkün değildir; yazmak, derleyici hatasıyla boğuşmak ve sanitizer çıktısını okumak gereklidir. Ders saatleri dışında her gün en az 30-60 dakika kod yazmaya hazır olmak beklenir.