Bir sınıftan nesne üretildiğinde, o nesnenin üyeleri için bellekte yer ayrılır ve ardından constructor çalışır. Constructor’ın adı sınıf adıyla aynıdır, dönüş tipi yoktur ve parametre alabilir. Amaç, nesneyi geçerli bir durumda başlatmaktır. Örneğin bir banka hesabının bakiyesi rastgele bir değerle değil, açıkça belirlenmiş bir başlangıç değeriyle yaşama başlamalıdır.

#include <iostream>
#include <string>

class BankaHesabi {
private:
    std::string sahip;
    double bakiye;

public:
    BankaHesabi(const std::string& isim, double ilkBakiye)
        : sahip(isim), bakiye(ilkBakiye) {
        std::cout << sahip << " için hesap açıldı.\n";
    }

    void paraYatir(double miktar) {
        if (miktar > 0) bakiye += miktar;
    }

    ~BankaHesabi() {
        std::cout << sahip << " nesnesi kapatılıyor.\n";
    }
};

Buradaki : sahip(isim), bakiye(ilkBakiye) bölümü üye başlatma listesidir. Atama işleminden daha doğrudan ve çoğu durumda daha verimlidir. Ayrıca const üyeler ve referans üyeler için tercih değil, zorunluluktur. Constructor çalıştıktan sonra nesnenin temel koşulu, yani sınıf değişmezi korunmuş olur. Örneğin bakiyenin negatif olmaması isteniyorsa bu kural daha ilk anda denetlenmelidir.

Destructor’ın önemi, nesnenin sahip olduğu kaynağın türü arttıkça büyür. Sadece int gibi basit üyeler için özel destructor yazmak gerekmez; derleyici zaten yeterli temizliği üretir. Ancak sınıf new ile bellek ayırıyor, dosya açıyor veya bir sistem kaynağını kilitliyorsa, bu kaynak mutlaka bırakılmalıdır. Kapsamdan çıkış normal bir return ile de olsa, hata nedeniyle exception fırlatılmasıyla da olsa destructor çağrılır.

#include <fstream>
#include <string>

class GunlukDosyasi {
private:
    std::ofstream dosya;

public:
    explicit GunlukDosyasi(const std::string& yol) : dosya(yol) {
        if (!dosya) throw std::runtime_error("Dosya açılamadı");
    }

    void yaz(const std::string& mesaj) {
        dosya << mesaj << '\n';
    }

    ~GunlukDosyasi() {
        // ofstream zaten kapanır; flush çağrısı niyeti görünür kılar.
        if (dosya.is_open()) dosya.flush();
    }
};

Bu desenin teorik adı RAII‘dır: Resource Acquisition Is Initialization. Kaynağın edinilmesi constructor’a, bırakılması destructor’a bağlanır. Böylece kaynak ömrü nesne ömrüne eşitlenir. Bir nesnenin yaşadığı süreyi kabaca $t_{yaşam} = t_{yıkım} - t_{oluşum}$ ile ifade edersek, RAII’da kaynak için de $t_{kaynak} = t_{yaşam}$ hedeflenir. Manuel delete veya close çağrısını unutma riski ciddi biçimde azalır.

Dinamik bellek gerekiyorsa ham işaretçiler yerine std::unique_ptr ve std::vector gibi RAII uyumlu standart araçları tercih edin. Böylece çoğu zaman destructor yazmanız bile gerekmez: buna Rule of Zero denir. Kalıtım kullanılan sınıflarda ise taban sınıf işaretçisi üzerinden silme ihtimali varsa destructor virtual olmalıdır. Kısacası iyi bir constructor nesneyi güvenilir biçimde başlatır; iyi tasarlanmış bir destructor da ayrılırken arkasında bellek sızıntısı ve açık kaynak bırakmaz.

``

Önce bellek haritasını anlayalım

Bir süreç çalıştırıldığında işletim sistemi ona geniş ve kesintisiz görünen bir sanal adres alanı sunar. Programın kullandığı adresler doğrudan fiziksel RAM adresleri değildir. Sayfa tabloları, sanal sayfaları fiziksel çerçevelere eşler.

Bir adres alanı kabaca kod, global veriler, stack ve heap bölgelerinden oluşur. malloc ile istediğimiz alan heap üzerinde yönetilir; ancak her malloc çağrısının anında yeni bir fiziksel sayfa ayırması gerekmez. İşletim sistemi sayfaları ihtiyaç anında eşleyebilir.

Bellek kullanımını basitleştirerek şöyle ifade edebiliriz:

Garbage collector’ın amacı, artık kök nesnelerden erişilemeyen $M_{erişilemeyen}$ bölümünü bulup yeniden kullanılabilir hâle getirmektir.

Mark-and-sweep nasıl çalışır?

Algoritma iki temel aşamadan oluşur:

1. Mark: Stack, global değişkenler veya çalışma zamanı tarafından tutulan köklerden başlanır. Ulaşılabilen bütün nesneler işaretlenir.
2. Sweep: Ayrılmış nesneler taranır. İşaretlenmemiş olanlar erişilemez kabul edilerek serbest bırakılır.

Bu örnekte gerçek stack taraması yapmayacağız. Bunun yerine kökleri açıkça kaydedeceğiz. Böylece algoritmanın özü, platforma özgü ayrıntılar arasında kaybolmayacak.

#include <stdio.h>
#include <stdlib.h>

typedef struct Object {
    int marked;
    int value;
    struct Object *ref;
    struct Object *next;
} Object;

static Object *heap = NULL;

Object *gc_alloc(int value) {
    Object *obj = malloc(sizeof(Object));
    if (!obj) {
        perror("malloc");
        exit(EXIT_FAILURE);
    }

    obj->marked = 0;
    obj->value = value;
    obj->ref = NULL;
    obj->next = heap;
    heap = obj;
    return obj;
}

void mark(Object *obj) {
    if (obj == NULL || obj->marked)
        return;

    obj->marked = 1;
    mark(obj->ref);
}

void sweep(void) {
    Object **cursor = &heap;

    while (*cursor) {
        Object *obj = *cursor;
        if (!obj->marked) {
            *cursor = obj->next;
            printf("Silindi: %d\n", obj->value);
            free(obj);
        } else {
            obj->marked = 0;
            cursor = &obj->next;
        }
    }
}

void collect(Object **roots, size_t count) {
    for (size_t i = 0; i < count; i++)
        mark(roots[i]);
    sweep();
}

heap listesi ayrılan tüm nesnelerin envanteridir. ref, bir nesneden diğerine referans oluşturarak küçük bir nesne grafiği kurar. mark fonksiyonu bu grafiği derinlik öncelikli dolaşır. Döngüsel referanslarda sonsuz özyinelemeyi marked kontrolü engeller.

Collector’ı deneyelim

int main(void) {
    Object *a = gc_alloc(10);
    Object *b = gc_alloc(20);
    Object *orphan = gc_alloc(99);

    a->ref = b;

    Object *roots[] = { a };
    collect(roots, 1);

    roots[0] = NULL;
    collect(roots, 1);
    return 0;
}

İlk koleksiyonda a köktür; b nesnesine a->ref üzerinden ulaşılır. orphan ise hiçbir kökten erişilemediği için silinir. İkinci koleksiyonda kök kaldırıldığından hem a hem b temizlenir. Referans döngüsü kurulsa bile kökten ulaşılamayan nesneler toplanabilir; bu, referans sayımına göre önemli bir avantajdır.

Gerçek sistemlerden farkı

Bu oyuncak collector thread güvenliği, bellek sıkıştırma, nesil tabanlı toplama ve stack taraması sunmaz. Ayrıca özyinelemeli mark, çok derin grafiklerde stack taşmasına yol açabilir. Üretim sistemleri iş listesinden yararlanan yinelemeli tarama, tri-color marking ve eşzamanlı toplama gibi yöntemler kullanır.

Yine de proje kritik fikri gösterir: free işlemini otomatikleştirmek yalnızca adresleri takip etmek değildir; programın canlı nesne grafiğini anlamaktır. Sanal bellek bize adres alanını sağlar, allocator blokları dağıtır, garbage collector ise bu bloklardan hangilerinin artık hikâyede rolü kalmadığına karar verir.

``

Kalıtımın ana fikri “bir türüdür” (is-a) ilişkisidir. Örneğin bir Araba bir Arac türüdür; dolayısıyla aracın marka, hız ve hareket etme gibi genel niteliklerini miras alabilir. Buna karşılık, bir arabanın motoru olması “sahiptir” (has-a) ilişkisidir ve genellikle composition ile modellenmelidir. Bu ayrımı doğru yapmak, sürdürülebilir tasarımın ilk savunma hattıdır.

C++’ta türetilmiş sınıf, temel sınıfın public üyelerine doğrudan erişebilir; private üyeler ise miras alınmış olsalar bile doğrudan erişilemez. Bu kural kapsüllemeyi korur. Temel sınıfın kontrollü erişim için sunduğu protected alanlar vardır, fakat veri üyelerini çoğunlukla private tutup metotlarla yönetmek daha güvenlidir.

#include <iostream>
#include <string>

class Arac {
private:
    std::string marka;
    int hiz;

public:
    Arac(const std::string& marka) : marka(marka), hiz(0) {}

    void hizlan(int miktar) {
        hiz += miktar;
    }

    void bilgileriYazdir() const {
        std::cout << marka << " - " << hiz << " km/s\n";
    }
};

class ElektrikliAraba : public Arac {
private:
    int bataryaYuzdesi;

public:
    ElektrikliAraba(const std::string& marka, int batarya)
        : Arac(marka), bataryaYuzdesi(batarya) {}

    void sarjDurumunuYazdir() const {
        std::cout << "Batarya: %" << bataryaYuzdesi << "\n";
    }
};

Burada ElektrikliAraba : public Arac ifadesi, herkese açık kalıtımı anlatır. ElektrikliAraba nesnesi, Aracın açık arayüzünü korur; yani hizlan() ve bilgileriYazdir() çağrılabilir. Kurucu listesinde yer alan Arac(marka) çağrısı da önemlidir: Önce temel sınıf bölümü, ardından türetilmiş sınıf bölümü oluşturulur.

Kalıtımın gerçek gücü, çok biçimlilikle (polymorphism) birleştiğinde görünür. Temel sınıftaki bir metodu virtual yaparsak, temel sınıf işaretçisi üzerinden doğru türetilmiş sınıf davranışı çalışma zamanında seçilir. Mantıksal olarak bu seçim $O(1)$ düzeyinde bir sanal tablo yönlendirmesiyle gerçekleşir; getirisi ise farklı türleri ortak bir arayüzde işleyebilmektir.

class Bildirim {
public:
    virtual void gonder() const {
        std::cout << "Genel bildirim\n";
    }
    virtual ~Bildirim() = default;
};

class EpostaBildirimi : public Bildirim {
public:
    void gonder() const override {
        std::cout << "E-posta gönderildi.\n";
    }
};

void bildir(const Bildirim& kanal) {
    kanal.gonder();
}

bildir() fonksiyonu hangi bildirim türüyle çalıştığını bilmek zorunda değildir. Bu, açık/kapalı ilkesini destekler: Mevcut kodu değiştirmeden yeni SMSBildirimi sınıfları ekleyebilirsiniz. Ancak her ortak alan için kalıtım kullanmayın. Derin hiyerarşiler, sıkı bağımlılık ve kırılgan taban sınıf sorunları doğurabilir. Sağlam bir kural şudur: Gerçek bir is-a ilişkisi yoksa bileşimi tercih edin; varsa küçük, anlaşılır ve sanal yıkıcısı olan arayüz tabanlı sınıflar tasarlayın.

Bu ifade referansın ayrı bir değer kopyası olmadığını anlatır. Yine de C++ standardı, referansların bellekte nasıl tutulacağını uygulamaya bırakır; çoğu mimaride derleyici bunu işaretçi benzeri bir mekanizmayla uygular.

#include <iostream>

void zamYap(int& maas, int miktar) {
    maas += miktar; // Çağıranın değişkeni doğrudan güncellenir.
}

int main() {
    int maas = 30000;
    int& bordroKaydi = maas;

    bordroKaydi = 32000;
    zamYap(maas, 2500);

    std::cout << maas << '\n'; // 34500
}

Burada zamYap, sonucu return etmek yerine çağıranın verisini değiştirir. Bu yaklaşım büyük nesneleri kopyalamaktan da kaçınabilir. Fakat yan etki içerdiği için fonksiyon adı ve dokümantasyonu niyeti açıkça belirtmelidir.

Referansın en yaygın ve en güvenli kullanım biçimi, salt-okunur büyük verileri const referansla almaktır. Bir std::string, std::vector veya kendi sınıfınızı değerle geçirmek maliyetli kopyalar üretebilir. const T& ise kopyalamaz ve fonksiyonun nesneyi değiştirmeyeceğini derleyici düzeyinde garanti eder.

#include <string>
#include <iostream>

void kullaniciyiSelamla(const std::string& ad) {
    // ad += "!"; // Hata: const referans değiştirilemez.
    std::cout << "Merhaba, " << ad << "!\n";
}

const referanslar geçici değerlere de bağlanabilir. Örneğin const std::string& mesaj = "Merhaba"; geçerlidir; geçicinin ömrü referansın kapsamına kadar uzatılır. Buna karşılık normal, yani const olmayan T&, geçici bir nesneye bağlanamaz. Bu kural, kısa ömürlü bir nesneyi yanlışlıkla değiştirmeye çalışmayı engeller.

Önemli bir ayrım da şudur: Referansı daha sonra başka bir nesneye “yönlendiremezsiniz”. Aşağıdaki atama referansı değil, bağlı olduğu değeri değiştirir:

int a = 10;
int b = 20;
int& r = a;
r = b; // r hâlâ a'nın takma adı; a artık 20 olur.

Referanslar güvenliği artırsa da ömür sorunlarını sihirli biçimde çözmez. Bir fonksiyondan yerel değişkene referans döndürmek tanımsız davranışa yol açar; fonksiyon bitince o değişken yok olur. Ayrıca bir nesne silindikten sonra ona bağlı referansı kullanmak da hatalıdır.

Kısacası referans, “bu nesne kesinlikle var ve onunla çalışıyorum” demenin C++ dilindeki güçlü ifadesidir. İşaretçileri tamamen gereksiz kılmaz; ancak zorunlu, boş olmayan ve okunaklı bağlantılar için çoğu zaman ilk tercih olmalıdır.

Jenerik programlamanın temel fikri şudur: Algoritma, belirli bir sınıf adına değil, ihtiyaç duyduğu davranışlara bağımlı olmalıdır. Örneğin bir sıralama algoritması, elemanların int olmasını istemez; yalnızca karşılaştırılabilir olmalarını ister. Bu yaklaşımın basit maliyet modeli şöyle özetlenebilir:

Şablon kullanmak algoritmanın asimptotik karmaşıklığını değiştirmez. Örneğin sıralama hâlâ çoğu durumda $O(n \log n)$’dir. Ancak derleyici türü bildiği için çağrıları satır içine alma (inlining) ve özel optimizasyonlar yapabilir.

Fonksiyon şablonu: Türü derleyici bulsun

En tanıdık örnek, iki değerden büyüğünü döndüren bir fonksiyon şablonudur:

#include <iostream>
#include <string>

template <typename T>
const T& maksimum(const T& a, const T& b) {
    return (a > b) ? a : b;
}

int main() {
    std::cout << maksimum(12, 8) << "\n";
    std::cout << maksimum(3.14, 6.28) << "\n";
    std::cout << maksimum(std::string{"Ada"}, std::string{"Zeynep"});
}

typename T yerine class T da yazılabilir; bu bağlamda anlamları aynıdır. Derleyici ilk çağrıda T = int, ikinci çağrıda T = double ve son çağrıda T = std::string olacak şekilde gerekli sürümleri üretir. Fakat burada görünmez bir sözleşme vardır: T için > operatörü tanımlı olmalıdır. Jenerik kodun gücü kadar sorumluluğu da bu sözleşmeleri doğru kurmaktır.

Sınıf şablonları ve tür parametreleri

Şablonlar yalnızca fonksiyonlar için değildir. Aşağıdaki Kutu, içinde hangi değer saklanacağını kullanıcıya bırakır:

#include <utility>

template <typename T>
class Kutu {
public:
    explicit Kutu(T deger) : deger_(std::move(deger)) {}

    const T& al() const { return deger_; }
    void ayarla(T yeniDeger) { deger_ = std::move(yeniDeger); }

private:
    T deger_;
};

Kutu<int> ve Kutu<std::string> birbirinden farklı türlerdir. Bu önemli ayrım, yanlış türde atamaları daha program çalışmadan yakalar. Ayrıca modern C++’ta şablon parametreleri yalnızca tür olmak zorunda değildir: std::array<int, 10> örneğindeki 10, derleme zamanı değer parametresidir.

Kısıtlar: Her T gerçekten uygun mu?

Eski C++ tarzında hatalar, şablonun gövdesi örneklendiğinde uzun derleyici mesajlarıyla ortaya çıkabilirdi. C++20 concept yapısı, beklentiyi açıkça ifade eder:

#include <concepts>

template <std::totally_ordered T>
const T& maksimumGuvenli(const T& a, const T& b) {
    return a > b ? a : b;
}

Buradaki std::totally_ordered, türün anlamlı karşılaştırma işlemlerine sahip olmasını ister. Böylece hata mesajı “> bulunamadı” ayrıntısına boğulmak yerine, fonksiyonun beklediği kavramı anlatır.

Şablonları kullanırken iki dengeyi koruyun: Arayüzü mümkün olduğunca genel tutun, ancak belirsiz davranışa izin verecek kadar da gevşetmeyin. Standart kütüphanedeki std::vector, std::sort ve std::optional bu felsefenin güçlü örnekleridir. İyi tasarlanmış jenerik kod, türleri değil yetenekleri hedefler; C++ derleyicisi de bu soyut fikri somut, hızlı makine koduna dönüştürür.

``

C tarafındaki struct, farklı alanları tek bir çatı altında gruplamak için harikadır; ancak üyeleri varsayılan olarak dışarıya açıktır. Herhangi bir kod parçası bakiyeyi doğrudan değiştirebilir. C++ içindeki class ise yalnızca veri grubu değil, aynı zamanda davranış tanımıdır. Sınıfın içindeki fonksiyonlara üye fonksiyon veya metot denir.

Kapsüllemenin ana fikri şudur: Bir nesnenin iç durumu, her isteyen tarafından rastgele değiştirilememelidir. Matematiksel olarak bir hesabın bakiyesi için şu değişmezi korumak isteyelim:

Eğer bakiye alanı herkese açık olursa, birisi bakiye = -500; yazabilir. Oysa para çekme işlemini bir metot üzerinden geçirirsek, sınıf bu kuralı her çağrıda denetler. Böylece nesnenin geçerli durumunu korumak tek bir noktadan yönetilir.

Aşağıdaki örnek, bir BankaHesabi sınıfının temel hâlidir:

#include <iostream>
#include <string>

class BankaHesabi {
private:
    std::string hesapSahibi;
    double bakiye;

public:
    BankaHesabi(const std::string& sahip, double ilkBakiye)
        : hesapSahibi(sahip), bakiye(ilkBakiye >= 0 ? ilkBakiye : 0) {}

    void paraYatir(double miktar) {
        if (miktar > 0) {
            bakiye += miktar;
        }
    }

    bool paraCek(double miktar) {
        if (miktar > 0 && miktar <= bakiye) {
            bakiye -= miktar;
            return true;
        }
        return false;
    }

    double bakiyeGetir() const {
        return bakiye;
    }
};

int main() {
    BankaHesabi hesap("Ada", 1000);
    hesap.paraYatir(250);

    if (!hesap.paraCek(2000)) {
        std::cout << "Yetersiz bakiye!\n";
    }

    std::cout << hesap.bakiyeGetir() << " TL\n";
}

Burada private altındaki hesapSahibi ve bakiye, sınıfın dışından erişilemez. Yani hesap.bakiye = -10; derleme hatası üretir. public bölümündeki metotlar ise sınıfın kontrollü arayüzüdür. Kullanıcı bakiyeyi okuyabilir veya değiştirmeyi talep edebilir; fakat kuralları sınıf belirler.

const anahtar sözcüğü de küçük ama güçlü bir sözleşmedir. bakiyeGetir() const, bu metodun nesnenin durumunu değiştirmeyeceğini söyler. Derleyici bu sözü denetler; böylece salt-okunur metotlara yanlışlıkla değişiklik eklemek zorlaşır.

İyi tasarlanmış bir sınıf, kullanıcıya “nasıl sakladığımı düşünme, ne yapabildiğimi kullan” der. Bugün bakiye double ile tutulabilir; yarın hassas para işlemleri için kuruş cinsinden long long kullanılabilir. Arayüz aynı kaldığı sürece sınıfı kullanan kodların çoğu etkilenmez. İşte kapsülleme, yalnızca erişim engeli değil; değişime dayanıklı, kuralları net ve daha güvenilir yazılım tasarlama sanatıdır.

STL üç ana fikrin birleşimidir: container (veriyi tutar), iterator (veri üzerinde dolaşır) ve algorithm (veriye işlem uygular). Bu ayrım oldukça değerlidir: std::sort, hangi sınıftan geldiğini umursamadan rastgele erişim sunan bir aralık üzerinde çalışır. Böylece veri ile işlem birbirine sıkı sıkıya bağlanmaz.

En sık kullanılan container’lar aşağıdaki gibi karşılaştırılabilir:

Bir vector fiziksel olarak çoğunlukla bitişik bellekte yaşar. Bu nedenle v[i] erişimi $O(1)$ zamanlıdır ve işlemci önbelleğinden iyi yararlanır. Sona ekleme (push_back) normalde $O(1)$, kapasite dolduğunda ise yeni alan ayırma nedeniyle $O(n)$ maliyetli olabilir. Buna rağmen büyümenin seyrek gerçekleşmesi sebebiyle amortize maliyet şöyledir:

Aşağıdaki örnek, sayıları sıralar, tekrarları temizler ve ikili arama yapar. Buradaki kritik nokta, binary_search fonksiyonunun doğru sonuç vermesi için aralığın önceden sıralı olmasıdır.

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

int main() {
    std::vector<int> puanlar{42, 17, 42, 99, 8, 17};

    std::sort(puanlar.begin(), puanlar.end());
    auto yeniSon = std::unique(puanlar.begin(), puanlar.end());
    puanlar.erase(yeniSon, puanlar.end());

    int aranan = 42;
    bool bulundu = std::binary_search(
        puanlar.begin(), puanlar.end(), aranan);

    std::cout << (bulundu ? "Puan bulundu" : "Puan yok") << '\n';
}

unique doğrudan eleman silmez; tekrar edenleri sona taşıyıp yeni mantıksal sonu döndürür. Bu yüzden silme işlemi için erase ile birlikte kullanılır. Bu kalıp, STL öğrenirken önemli olan iterator mantığını da gösterir.

Algoritma seçimi performansı dramatik biçimde değiştirir:

Örneğin 1 milyon eleman içinde doğrusal arama en kötü durumda yaklaşık $10^6$ karşılaştırma isterken, ikili arama yaklaşık $\log_2(10^6) \approx 20$ adımda sonuca ulaşabilir. Elbette sıralamanın da bir bedeli vardır; veri yalnızca bir kez aranacaksa sort her zaman kazanç sağlamaz. Çok sayıda sorgu yapılacaksa ise sıralama maliyeti kısa sürede kendini öder.

Pratik kural basittir: İndeksleme ve yoğun dolaşma için önce vector düşünün; yalnızca gerçekten gerekli olduğunda list seçin. LIFO davranışı için stack, iki uçtan işlem için deque kullanın. Ardından el yazımı döngülere geçmeden sort, find, count, transform ve lower_bound gibi algoritmaları inceleyin. STL, yalnızca daha kısa kod değil; karmaşıklığı görünür, niyeti açık ve bakımı kolay C++ kodu demektir.

``

Derleme süreci nasıl çalışır?

C/C++ kaynak kodu doğrudan işlemci tarafından anlaşılmaz. Yazdığımız .c veya .cpp dosyaları birkaç aşamadan geçer:

1. Ön işleme: #include ve #define ifadeleri işlenir.
2. Derleme: Kod, assembly diline dönüştürülür.
3. Assembly: Makine kodunu içeren nesne dosyası üretilir.
4. Bağlama: Nesne dosyaları ve kütüphaneler tek programda birleştirilir.

Basitleştirilmiş dönüşüm şöyledir:

Donanıma yakınlık özellikle veri boyutlarında hissedilir. Örneğin $N$ bitlik işaretsiz bir tamsayı, $0$ ile $2^N-1$ arasındaki değerleri temsil edebilir. Belleğin sınırlı olduğu gömülü sistemlerde seçilen veri türü bu nedenle önemlidir.

Derleyici kurulumu

Ubuntu ve Debian tabanlı sistemlerde GCC araç zinciri şu komutla kurulabilir:

sudo apt update
sudo apt install build-essential gdb

Clang kullanmak isteyenler ayrıca şunu çalıştırabilir:

sudo apt install clang lldb

macOS üzerinde Terminal’den xcode-select --install komutu Apple Clang araçlarını kurar. Windows’ta ise MSYS2 kurulup UCRT64 terminalinde aşağıdaki komut kullanılabilir:

pacman -S mingw-w64-ucrt-x86_64-gcc mingw-w64-ucrt-x86_64-gdb

Ardından MSYS2’nin ucrt64/bin klasörü PATH değişkenine eklenmelidir. Kurulumu doğrulamak için gcc --version, g++ --version veya clang --version çalıştırılır.

İlk program ve manuel derleme

main.cpp adında bir dosya oluşturalım:

#include <iostream>

int main() {
    int sayi = 42;
    std::cout << "Bellekteki değer: " << sayi << '\n';
    return 0;
}

Programı GCC ile derlemek için şu komut yeterlidir:

g++ -std=c++20 -Wall -Wextra -g main.cpp -o uygulama

Burada -std=c++20 dil standardını seçer, -Wall -Wextra olası hatalar için uyarıları açar, -g ise hata ayıklama bilgisi ekler. Linux/macOS üzerinde program ./uygulama, Windows’ta uygulama.exe komutuyla çalıştırılır.

VS Code yapılandırması

VS Code’a C/C++ uzantısını kurduktan sonra proje klasöründe .vscode/tasks.json dosyası oluşturulur:

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "C++ Derle",
      "type": "shell",
      "command": "g++",
      "args": [
        "-std=c++20",
        "-Wall",
        "-Wextra",
        "-g",
        "${file}",
        "-o",
        "${fileDirname}/${fileBasenameNoExtension}"
      ],
      "group": { "kind": "build", "isDefault": true },
      "problemMatcher": ["$gcc"]
    }
  ]
}

Bu görev, açık olan dosyayı Ctrl+Shift+B ile derler. Clang tercih ediliyorsa command alanı clang++ yapılabilir.

Hata ayıklama sırasında breakpoint kullanmak, değişkenlerin bellekteki değişimini adım adım izlemeyi sağlar. VS Code’un Run and Debug bölümünden C++ yapılandırması seçildiğinde GDB veya LLDB çalıştırılır. Böylece yalnızca programın sonucunu değil; çağrı yığınını, işaretçileri ve bellek adreslerini de inceleyebilirsiniz.

Son olarak derleyici uyarılarını düşman değil, ücretsiz kod inceleme ekibi olarak görün. C/C++ öğrenirken -Wall -Wextra kullanmak ve küçük programları hata ayıklayıcıyla yürütmek, bellek yönetimi ile donanım arasındaki ilişkiyi çok daha görünür hâle getirir.

``

Derleme zincirindeki yeri

Bir C/C++ programının yolculuğu kabaca dört adımdan oluşur. Ön işlemci ilk adımda kaynak metni düzenler; henüz tür kontrolü yapmaz, fonksiyon çağırmaz ve C++ sözdizimini derinlemesine analiz etmez. Temel olarak karakter dizileri üzerinde çalışır.

Örneğin #include <stdio.h> yazdığınızda ön işlemci, ilgili başlık dosyasının içeriğini mantıksal olarak o satıra ekler. Bu yüzden başlık dosyalarında tekrar eden eklemeleri önlemek kritik önemdedir.

#define: Metinsel kısayol, sihirli değnek değil

Nesne benzeri makrolar sabit metinleri değiştirir. Fonksiyon benzeri makrolar ise parametre alabilir:

#include <stdio.h>

#define MAX_KULLANICI 100
#define KARE(x) ((x) * (x))

int main(void) {
    int sayi = 5;
    printf("Limit: %d, kare: %d\n", MAX_KULLANICI, KARE(sayi + 1));
}

Burada KARE(sayi + 1), ((sayi + 1) * (sayi + 1)) biçimine dönüşür. Parantezler hayati ayrıntıdır. #define KARE(x) x * x olsaydı KARE(2 + 3) ifadesi 2 + 3 * 2 + 3 olur ve beklenen $25$ yerine $11$ üretirdi.

Makroların tür bilgisi yoktur; bu nedenle modern C++ kodunda sabitler için çoğu zaman constexpr, küçük işlevler için inline fonksiyonlar daha güvenlidir.

Koşullu derleme: Kodun hangi evrende yaşayacağını seçmek

#if, #ifdef, #ifndef, #elif ve #endif, belirli blokların ön işlemci tarafından korunmasını veya silinmesini sağlar. Özellikle hata ayıklama, özellik bayrakları ve işletim sistemi farkları için kullanılır.

#include <stdio.h>

#define DEBUG_MODU

int main(void) {
#ifdef DEBUG_MODU
    printf("[DEBUG] Program baslatildi.\n");
#endif

#if defined(_WIN32)
    printf("Windows platformu\n");
#else
    printf("Windows disindaki bir platform\n");
#endif
    return 0;
}

DEBUG_MODU tanımlı değilse debug satırı derleyiciye hiç ulaşmaz. Bu, if (false) yazmaktan farklıdır: ikinci durumda kod hâlâ sözdizimsel olarak geçerli olmak zorundadır; koşullu derlemede ise blok kaynak çıktıdan tamamen çıkar.

Başlık dosyalarında klasik koruma deseni de aynı fikri kullanır:

#ifndef HESAPLAYICI_H
#define HESAPLAYICI_H

int topla(int a, int b);

#endif

Bu yapı, dosya birden fazla kez eklense bile bildirimin yalnızca bir kez işlenmesini sağlar. Ön işlemci güçlüdür; fakat metinsel çalıştığı için dikkat ister. Makroları küçük, açık isimli ve zorunlu oldukları alanlarla sınırlı tutmak, derleme sahnesinin perde arkasını kontrol altında tutmanın en iyi yoludur.

``

Bağlama zamanı neden önemlidir?

Bir fonksiyon çağrısının hangi fonksiyona gideceğine karar verilmesine bağlama (binding) denir. Normal üye fonksiyonlarda karar derleme zamanında verilir; bu, erken bağlamadır. virtual anahtar sözcüğü ise kararı çalışma zamanına bırakır: geç bağlama (late binding).

Teorik olarak, temel sınıf işaretçisinin türü $B$ ve işaret ettiği gerçek nesnenin türü $D$ olsun. Virtual bir çağrının seçimi işaretçinin statik türüne değil, nesnenin dinamik türüne bağlıdır:

Bu küçük görünen fark, kalıtım zincirinin gerçek gücünü açığa çıkarır. Aşağıdaki tabloda iki yaklaşımın özeti bulunuyor:

Kedi mi konuşuyor, hayvan mı?

Önce temel sınıfın ortak sözleşmeyi tanımladığını düşünelim. speak() tüm hayvanlar için anlamlıdır, fakat ürettiği ses her hayvanda farklıdır. Saf sanal fonksiyon kullanmak, Animal sınıfının doğrudan nesne üretmek yerine bir soyutlama olduğunu açıkça söyler.

#include <iostream>
#include <memory>
#include <vector>

class Animal {
public:
    virtual void speak() const = 0;
    virtual ~Animal() = default;
};

class Cat : public Animal {
public:
    void speak() const override {
        std::cout << "Miyav!\n";
    }
};

class Dog : public Animal {
public:
    void speak() const override {
        std::cout << "Hav hav!\n";
    }
};

int main() {
    std::vector<std::unique_ptr<Animal>> animals;
    animals.push_back(std::make_unique<Cat>());
    animals.push_back(std::make_unique<Dog>());

    for (const auto& animal : animals) {
        animal->speak();
    }
}

Burada animals vektörü yalnızca Animal arayüzünü bilir. Buna rağmen ilk çağrı Cat::speak(), ikinci çağrı Dog::speak() olur. Derleyici bu davranışı çoğu uygulamada vtable adı verilen fonksiyon işaretçisi tablosu üzerinden gerçekleştirir. Standart, vtable’ın tam uygulama ayrıntısını zorunlu kılmaz; ancak zihinsel model olarak oldukça faydalıdır.

override ve sanal yıkıcı: İki önemli emniyet kemeri

Türetilmiş sınıfta override kullanmak zorunlu değildir, ama güçlü biçimde önerilir. Örneğin yanlışlıkla void speak() yerine void speak(int) yazarsanız, derleyici bunun üst sınıftaki fonksiyonu ezmediğini hemen bildirir. Böylece sessiz ve pahalı hatalar önlenir.

Bir diğer kritik ayrıntı, temel sınıfın yıkıcısının virtual olmasıdır. Aksi halde Animal* üzerinden silinen bir Cat nesnesinde türetilmiş sınıfın yıkıcısı çalışmayabilir. Kaynak yöneten sınıflarda bu durum bellek sızıntısı veya eksik temizlik demektir.

Sonuç olarak çok biçimlilik, if ve switch zincirleriyle tür kontrolü yapma ihtiyacını azaltır. Sisteme yeni bir Bird sınıfı eklediğinizde mevcut döngüyü değiştirmek yerine yalnızca speak() davranışını tanımlarsınız. İşte geç bağlama, C++ kodunu hem daha okunur hem de değişime daha dayanıklı yapan mekanizmadır.