C++23 ve Gelecek | Ücretsiz C++ Programlama: Sıfırdan İleri Seviyeye Kursu

C++ sürekli evrim geçiren bir dil. 1979'da Bjarne Stroustrup'un "C with Classes" olarak başlattığı proje, bugün dünyanın en güçlü ve en yaygın kullanılan dillerinden biri. Her üç yılda bir yeni standart yayınlanır ve her standart dili daha güvenli, daha okunabilir ve daha güçlü hale getirir.

Bu derste C++'ın evrim tarihçesini, C++20 ve C++23'ün öne çıkan özelliklerini ve senin için bir öğrenme yol haritası çizeceğiz. Bu ders bir kapanış dersi — nereden geldiğini gör, nereye gittiğini planla.

C++ Standart Sürümleri Tarihçesi

C++'ın evrimini bir bina inşaatı gibi düşün. C++98 temeli attı, C++11 binayı modernize etti, sonraki sürümler ise her seferinde yeni katlar ekledi.

C++98/03 — Temel

İlk resmi standart. STL (Standard Template Library), template'ler, exception handling burada tanımlandı. C++03 küçük düzeltmeler içerdi.

C++11 — Modern C++ Devrimi

C++'ı tamamen değiştiren devasa bir güncelleme:

auto keyword
Range-based for loop
Lambda expressions
Smart pointers (unique_ptr, shared_ptr)
Move semantics ve rvalue references
nullptr, constexpr, enum class
std::thread, std::mutex

C++11 öncesi ve sonrası neredeyse farklı diller gibidir. "Modern C++" denince C++11 ve sonrası kastedilir.

C++14 — İyileştirmeler

C++11'in üstüne küçük ama kullanışlı eklemeler:

Generic lambda'lar (auto parametreli)
std::make_unique
Binary literal (0b1010)
Return type deduction

C++17 — Pratik Kolaylıklar

Günlük kodlamayı kolaylaştıran özellikler:

Structured bindings (auto [x, y] = pair;)
std::optional, std::variant, std::any
if constexpr — derleme zamanı if
std::filesystem
Class template argument deduction (CTAD)
std::string_view

C++20 — İkinci Büyük Devrim

C++11'den sonraki en büyük güncelleme:

Concepts
Ranges
Coroutines
Modules
std::format
Three-way comparison (<=> spaceship operator)
consteval, constinit

C++23 — Olgunlaşma

C++20'nin üzerine pratik eklemeler:

std::print / std::println
Deducing this
std::expected
std::flat_map, std::flat_set
Ranges iyileştirmeleri
std::generator

1998    2003    2011    2014    2017    2020    2023    2026
 │       │       │       │       │       │       │       │
C++98  C++03  C++11  C++14  C++17  C++20  C++23  C++26
         │       │                   │       │
       Minor   DEVRIM            DEVRIM  Olgunlasma

C++20 Özet

C++20 büyük bir standart. Dört ana özelliğine kısaca bakalım.

Concepts — Şablon Kısıtlamaları

Template'lere "bu tür şu özelliklere sahip olmalı" demenin yolu. Eskiden template hataları anlaşılmaz metinlerdi, concepts ile hatalar net ve okunabilir.

#include <concepts>
#include <iostream>

// Sayi turlerini kabul eden bir fonksiyon
template<typename T>
requires std::integral<T> || std::floating_point<T>
T topla(T a, T b) {
    return a + b;
}

// Daha kisa syntax
template<std::integral T>
T kare(T x) {
    return x * x;
}

int main() {
    std::cout << topla(3, 5) << "\n";        // OK: int
    std::cout << topla(1.5, 2.5) << "\n";    // OK: double
    // topla("a", "b");  // HATA: string integral/floating_point degil
    std::cout << kare(7) << "\n";
    return 0;
}

Concepts olmadan, topla("a", "b") çağrısı sayfalarca anlaşılmaz hata üretirdi. Concepts ile tek satır: "string, integral veya floating_point concept'ini karşılamıyor."

Ranges — Modern STL Algoritmaları

Ranges, STL algoritmalarını daha modern ve okunabilir hale getirir. Iterator çiftleri yerine doğrudan container'ları kullanabilirsin.

#include <iostream>
#include <vector>
#include <ranges>
#include <algorithm>

int main() {
    std::vector<int> sayilar = {5, 3, 8, 1, 9, 2, 7, 4, 6};

    // Eski yol
    std::sort(sayilar.begin(), sayilar.end());

    // Ranges yolu
    std::ranges::sort(sayilar);

    // Pipe syntax ile zincirleme
    auto sonuc = sayilar
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::views::transform([](int x) { return x * x; });

    for (int x : sonuc) {
        std::cout << x << " ";  // 4 16 36 64
    }
    std::cout << "\n";

    return 0;
}

| (pipe) operatörü ile işlemleri zincirleme yapabilirsin — tıpkı Unix pipe'ları gibi. Her adım tembel değerlendirme (lazy evaluation) yapar — yani sonuçlar ihtiyaç duyulana kadar hesaplanmaz.

Coroutines — Asenkron Programlama

Coroutines, bir fonksiyonun çalışmasını durdurup sonra devam ettirmesini sağlar. co_await, co_yield, co_return anahtar kelimeleri ile kullanılır.

Coroutine'ler doğrudan kullanımı karmaşık bir özelliktir — genellikle bir kütüphane üzerinden kullanılır. Ama temel fikri bilmek önemli:

// Kavramsal ornek — gercek coroutine altyapisi gerektirir
Generator<int> fibonacci() {
    int a = 0, b = 1;
    while (true) {
        co_yield a;        // degeri don ve dur
        auto temp = a + b;
        a = b;
        b = temp;
    }
}

Modules — Başlık Dosyalarının Geleceği

Modules, #include sisteminin modern alternatifidir. Derleme süresini dramatik şekilde azaltır ve isim çakışmalarını önler.

// matematik.cppm — modul dosyasi
export module matematik;

export int topla(int a, int b) {
    return a + b;
}

// main.cpp
import matematik;

int main() {
    auto sonuc = topla(3, 5);
    return 0;
}

Modules henüz tüm derleyicilerde ve build sistemlerinde tam olarak desteklenmiyor. Ama gelecek standartların temel yapı taşı olacak.

C++23 Yenilikleri

C++23, günlük kullanımı kolaylaştıran pratik özellikler getirdi. İşte en önemlileri.

std::print ve std::println

Nihayet! printf'in tür güvenliği ile cout'un rahatlığını birleştiren bir çıktı fonksiyonu.

#include <print>
#include <string>
#include <vector>

int main() {
    std::println("Merhaba Dunya!");
    std::println("Ad: {}, Yas: {}", "Ali", 25);
    std::println("Pi: {:.2f}", 3.14159);

    // Format belirtecleri
    std::println("{:>10}", "sag");     //        sag
    std::println("{:<10}", "sol");     // sol
    std::println("{:^10}", "orta");    //    orta
    std::println("{:#x}", 255);        // 0xff

    return 0;
}

std::print yeni satır eklemez, std::println ekler. Format söz dizimi Python'un f-string'lerine benzer. cout ile << zincirleme çılgınlığına son!

Deducing This

Üye fonksiyonlarda this parametresini açıkça yazmana olanak tanır. Bu, CRTP gibi karmaşık kalıpları basitleştirir ve const/non-const overload tekrarını ortadan kaldırır.

#include <iostream>
#include <string>

class Metin {
    std::string veri_;
public:
    Metin(std::string s) : veri_(std::move(s)) {}

    // Eskiden iki ayri overload gerekiyordu:
    // const std::string& veriAl() const { return veri_; }
    // std::string& veriAl() { return veri_; }

    // C++23: tek fonksiyon, deducing this ile
    template<typename Self>
    auto&& veriAl(this Self&& self) {
        return std::forward<Self>(self).veri_;
    }
};

int main() {
    Metin m("merhaba");
    std::cout << m.veriAl() << "\n";

    const Metin cm("sabit");
    std::cout << cm.veriAl() << "\n";

    return 0;
}

std::expected — Hata Yönetiminde Yeni Yaklaşım

std::expected, bir fonksiyonun ya başarılı bir değer ya da hata bilgisi döndürmesini sağlar. Exception kullanmadan hata yönetimi.

#include <expected>
#include <string>
#include <iostream>

enum class Hata {
    SifiraBolme,
    NegatifSayi
};

std::expected<double, Hata> guvenlibol(double a, double b) {
    if (b == 0.0) {
        return std::unexpected(Hata::SifiraBolme);
    }
    return a / b;
}

std::expected<double, Hata> karekokAl(double x) {
    if (x < 0) {
        return std::unexpected(Hata::NegatifSayi);
    }
    return std::sqrt(x);
}

int main() {
    auto sonuc = guvenlibol(10.0, 3.0);
    if (sonuc) {
        std::cout << "Sonuc: " << *sonuc << "\n";
    } else {
        std::cout << "Hata olustu!\n";
    }

    auto sonuc2 = guvenlibol(10.0, 0.0);
    if (!sonuc2) {
        std::cout << "Hata: sifira bolme\n";
    }

    return 0;
}

std::expected<T, E> — T başarılı değer türü, E hata türü. Başarılıysa has_value() true döner ve *sonuc ile değere ulaşırsın. Hatalıysa error() ile hata bilgisini alırsın.

💡 `std::expected` vs exception: Exception'lar beklenmeyen hatalar için, expected beklenen hatalar için idealdir. Dosya bulunamadı? expected. Bellek bitti? Exception. Performans kritik kodda exception overhead'inden kaçınmak için expected tercih edilir.

Ranges Library — Kısa Giriş

Ranges, C++20'de geldi ve C++23'te genişletildi. STL algoritmalarını fonksiyonel programlama tarzında zincirleme imkanı sunar.

Temel View'lar

#include <iostream>
#include <vector>
#include <ranges>

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // Ilk 5 eleman
    for (int x : v | std::views::take(5)) {
        std::cout << x << " ";  // 1 2 3 4 5
    }
    std::cout << "\n";

    // Son 3 elemani atla
    for (int x : v | std::views::drop(3)) {
        std::cout << x << " ";  // 4 5 6 7 8 9 10
    }
    std::cout << "\n";

    // Tersten
    for (int x : v | std::views::reverse) {
        std::cout << x << " ";  // 10 9 8 7 6 5 4 3 2 1
    }
    std::cout << "\n";

    // Karmasik zincir: ciftleri al, karelerini hesapla, ilk 3
    auto sonuc = v
        | std::views::filter([](int x) { return x % 2 == 0; })
        | std::views::transform([](int x) { return x * x; })
        | std::views::take(3);

    for (int x : sonuc) {
        std::cout << x << " ";  // 4 16 36
    }
    std::cout << "\n";

    return 0;
}

Ranges'in güzelliği tembel değerlendirme (lazy evaluation). filter ve transform veriyi kopyalamaz — sadece elemanlara sırayla erişildiğinde hesaplama yapılır.

iota — Sayı Üreteci

#include <iostream>
#include <ranges>

int main() {
    // 1'den 10'a kadar
    for (int x : std::views::iota(1, 11)) {
        std::cout << x << " ";  // 1 2 3 4 5 6 7 8 9 10
    }
    std::cout << "\n";

    // Sonsuz seri (ilk 5'i al)
    for (int x : std::views::iota(1) | std::views::take(5)) {
        std::cout << x << " ";  // 1 2 3 4 5
    }
    std::cout << "\n";

    return 0;
}

Modules vs Headers

C++'ın geleneksel #include sistemi 1970'lerden kalma. Metin tabanlı yapıştırma (text-based inclusion) yapar — her .cpp dosyası aynı header'ı tekrar tekrar işler.

Özellik	Headers (#include)	Modules (import)
Derleme hızı	Yavaş (tekrar işleme)	Hızlı (bir kez derle)
Makro sızıntısı	Var (tehlikeli)	Yok
İsim çakışması	Olabilir	Kontrollü export
Include sırası önemli mi?	Evet	Hayır
Araç desteği	Mükemmel	Gelişiyor

// Header yolu — eski
#include <vector>
#include <string>
#include <iostream>

// Module yolu — yeni
import std;  // C++23 ile tum standart kutuphane

C++23 ile import std; tek satırda tüm standart kütüphaneyi içe aktarır. Derleme süresi dramatik şekilde azalır çünkü module bir kez derlenir ve cache'lenir.

Henüz tüm derleyiciler ve build sistemleri modules'ü tam desteklemiyor. Ama GCC, Clang ve MSVC hepsi aktif olarak çalışıyor. 2-3 yıl içinde modules yaygınlaşacak.

⚠️ Şu an için header'lardan modules'e geçiş acele etme. Kendi projelerinde deneyebilirsin ama üçüncü parti kütüphaneler henüz çoğunlukla header tabanlı. Geçiş kademeli olacak.

C++ Öğrenme Yol Haritası

Bu kursu tamamladıysan, temel ve orta seviye C++ bilgisine sahipsin. Peki bundan sonra ne yapmalısın?

Seviye 1: Temel ✅ (Bu Kurs)

Değişkenler, kontrol akışı, fonksiyonlar
OOP: class, inheritance, polymorphism
STL: vector, map, string, algorithm
Pointer'lar ve referanslar
Smart pointer'lar
Exception handling
Dosya işlemleri
Template temelleri

Seviye 2: İleri (Sıradaki Hedefin)

Derin template: variadic templates, SFINAE, concepts
Move semantics derinlemesine: perfect forwarding
Multithreading: thread pool, lock-free veri yapıları
Tasarım kalıpları: Factory, Observer, Strategy, RAII wrappers
Test yazma: Google Test, Catch2

Seviye 3: Uzman

Compiler internals: optimization, inlining, devirtualization
Performance tuning: cache-friendly kod, profiling (perf, Vtune)
Meta-programming: template meta-programming, constexpr her şey
Embedded / Systems: bare-metal C++, RTOS

Kariyer Tavsiyeleri

C++ nerede kullanılır?

Oyun motorları (Unreal Engine, Unity alt katman)
Finans (yüksek frekanslı ticaret - HFT)
Gömülü sistemler (otomotiv, IoT, robotik)
Sistem yazılımı (işletim sistemi, driver, veritabanı)
Bilimsel hesaplama (fizik simülasyonu, makine öğrenmesi altyapısı)
Medya işleme (video codec, ses işleme, grafik)

İş piyasasında C++ maaşları genellikle yüksektir çünkü iyi C++ geliştiricisi bulmak zordur. Dilin karmaşıklığı giriş bariyerini yükseltir ama ustalaşan için fırsatlar boldur.

Proje yaparak öğren. Teori önemli ama asıl öğrenme projelerde olur:

Basit bir oyun yap (konsol tabanlı tetris, snake)
Bir veri yapısı kütüphanesi yaz (kendi vector, map implementasyonun)
HTTP server veya chat uygulaması yap (networking öğren)
Bir emülatör yaz (CHIP-8 gibi basit bir platform)
Açık kaynak projelere katkıda bulun

Önerilen Kaynaklar ve Topluluklar

Kitaplar

"A Tour of C++" — Bjarne Stroustrup: Dilin yaratıcısından özet tur
"Effective Modern C++" — Scott Meyers: C++11/14 best practices
"C++ Concurrency in Action" — Anthony Williams: Multithreading
"The C++ Programming Language" — Stroustrup: Referans kitap

Online Kaynaklar

cppreference.com: En güncel ve kapsamlı referans
learncpp.com: Sıfırdan öğrenmek için mükemmel
godbolt.org (Compiler Explorer): Kodunun assembly çıktısını gör
cppinsights.io: Derleyicinin kodunu nasıl gördüğünü gösterir

Topluluklar

r/cpp (Reddit): Haberler ve tartışmalar
CppCon YouTube: Yıllık C++ konferansının videoları (ücretsiz)
C++ Slack/Discord: Soru sorma ve tartışma
Stack Overflow: Spesifik sorular için

Araçlar

CLion / VS Code: Modern IDE'ler
Clang-Tidy: Statik analiz ve kod kalitesi
Conan / vcpkg: Paket yöneticileri (kütüphane yönetimi)
CMake: Build sistemi (zaten öğrendin!)

💡 CppCon videolarını izle. Her yıl yüzlerce ücretsiz video yayınlanır. "Back to Basics" serisinden başla — temel konuları ustalardan dinlemek perspektifini genişletir.

Özet

C++ her 3 yılda güncellenir. C++11 modern C++'ı başlattı, C++17 pratik kolaylıklar ekledi, C++20 concepts/ranges/coroutines/modules ile ikinci büyük devrimi yaptı, C++23 std::print, std::expected, deducing this ile olgunlaştı.
Concepts, template'lere tür kısıtlaması ekler ve hata mesajlarını okunabilir hale getirir. Ranges, STL algoritmalarını pipe (|) syntax ile zincirlenebilir ve tembel (lazy) hale getirir.
std::print/println modern çıktı fonksiyonudur (cout'a alternatif). std::expected exception'sız hata yönetimi sağlar.
Modules, #include sisteminin modern alternatifidir — derleme hızını artırır, makro sızıntısını önler. Tam destek gelişiyor.
Öğrenme yol haritası: Temelden (bu kurs) → İleri (deep templates, multithreading, tasarım kalıpları) → Uzman (performance, meta-programming). Her seviyede proje yap.
Kaynaklar: cppreference.com (referans), learncpp.com (öğrenme), CppCon (videolar), godbolt.org (deneme). Toplulukla bağlantıda kal, açık kaynak projelere katkıda bulun.