C++ RAII VE OWNERSHIP NEDİR?

Üretim ortamında çalışan bir C++ servisinde yaşanan bir sahne: yeni eklenen bir özellik birkaç gün sonra "out of memory" hatasıyla servisi düşürmeye başlar. Sebep tek bir new çağrısının karşılığında delete unutulmuş olmasıdır. Aynı kod yolundan exception fırlatılınca da kaynak hiçbir zaman serbest bırakılmaz. Bu hikâye C++ dünyasında o kadar tipiktir ki Bjarne Stroustrup 1980'lerde diline bir kavram tasarımı eklemek zorunda kalmıştır: RAII. Bu yazı RAII'nin ne olduğunu, sahiplik (ownership) modeliyle nasıl iç içe geçtiğini ve modern C++'ta neden vazgeçilmez olduğunu pratik örneklerle anlatır.

RAII Neden Var?

RAII, Resource Acquisition Is Initialization (kaynak edinimi başlatma anındadır) ifadesinin kısaltmasıdır. Temel fikir basittir: bir kaynağı edinmek (heap belleği, dosya tanıtıcısı, mutex kilidi, soket, veritabanı bağlantısı) bir nesnenin constructor'ında olur; serbest bırakılması ise destructor'ında. Nesne kapsam dışına çıktığında destructor garanti olarak çağrılır — bu çağrı normal kontrol akışıyla da, exception ile de tetiklenir.

Bu garantinin önemi şuradadır: C++'ın iki güçlü özelliği vardır ki çoğu dilde yoktur — deterministic destruction (nesne yaşam süresinin sonu derleyici tarafından kesin bilinir) ve stack-allocated yıkıcı (otomatik bellek üzerindeki nesneler için yıkıcı kapsam çıkışında çağrılır). RAII bu iki özelliği kaynak yönetimi için bir mühendislik desenine dönüştürür; kavramın resmi dil tanımı ve örnekleri standart referansta ayrıntılı biçimde ele alınır.

Klasik Problem: Manuel Yönetimin Zorluğu

Aşağıdaki kod hem yaygın hem hatalıdır:

void process() {
    FILE* f = fopen("data.txt", "r");
    if (mayThrow()) {
        // exception atılırsa f hiçbir zaman kapanmaz
        return;
    }
    fclose(f);
}

Aynı kod RAII ile yazıldığında çok daha güvenlidir:

class FileHandle {
    FILE* f;
public:
    FileHandle(const char* path) { f = fopen(path, "r"); }
    ~FileHandle() { if (f) fclose(f); }
    // kopyalama yasaklanır, sahiplik tek elde tutulur
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
};

void process() {
    FileHandle h("data.txt");
    if (mayThrow()) return; // h yıkılır, fclose otomatik çağrılır
}

Bu desen yalnızca dosya için değil; mutex (std::lock_guard), heap bellek (std::unique_ptr), thread (std::jthread), soket ve özel API kaynakları için aynı şekilde çalışır. RAII C++'ı diğer manuel yönetim dillerinden ayıran tek en önemli idiom'dur.

Sahiplik (Ownership) Modeli

RAII bir kaynağın yaşam süresini bir nesneye bağlar. Sahiplik sorusu bunun bir adım ötesidir: aynı kaynağı hangi nesne sahiplenir? Kim onu serbest bırakma sorumluluğunu taşır?

C++'ta dört temel sahiplik biçimi vardır:

• Tek (unique) sahiplik: Tek bir nesne kaynağa sahiptir. O nesne yok olduğunda kaynak da serbest kalır. std::unique_ptr bu modeli temsil eder.
• Paylaşımlı (shared) sahiplik: Birden fazla nesne aynı kaynağa ortak sahip olur. Son sahip yok olunca kaynak serbest kalır. Referans sayma kullanılır. std::shared_ptr bu modeldir.
• Zayıf (weak) referans: Sahiplik vermez, sadece gözlemler. Kaynak başka bir shared_ptr tarafından zaten serbest bırakılmış olabilir. std::weak_ptr bunu sağlar.
• Borç (borrowed) erişim: Ham referans ya da pointer. Sahip değildir, sadece geçici erişim hakkıdır. Sahip nesne hâlâ hayattaysa güvenlidir.

İyi tasarlanmış bir C++ API'sinde her fonksiyon imzası bu sahiplik niyetini açıkça gösterir. Bir fonksiyon T* alıyor mu, const T& alıyor mu, std::unique_ptr<T> alıyor mu — bu seçim sözleşmenin parçasıdır.

Smart Pointer'larla RAII

Modern C++ (C++11 ve sonrası) RAII desenini standart kütüphane düzeyinde sağlar. Smart pointer'lar manuel new/delete kullanımını neredeyse tamamen ortadan kaldırır.

std::unique_ptr

Tek sahipliği temsil eder. Kopyalanamaz, sadece taşınabilir (move). Bellek maliyeti bir ham pointer kadardır — RAII'nin sıfır overhead örneğidir.

auto p = std::make_unique<Widget>(42);
// p kapsam dışına çıktığında ~Widget() çağrılır

std::shared_ptr

Birden fazla sahip mümkün olduğunda kullanılır. İçinde atomik referans sayacı tutar; her kopya sayacı bir artırır, her yıkım bir azaltır. Sayı sıfıra düştüğünde nesne yıkılır.

auto s = std::make_shared<Widget>(42);
auto s2 = s; // sayaç 2 oldu
// s ve s2 yıkıldığında Widget yıkılır

Shared_ptr'ın bir maliyeti vardır: atomik sayaç işlemleri ve ek tahsis. Gerçekten paylaşımlı sahiplik gerekmiyorsa unique_ptr tercih edilir. Pratikte unique_ptr varsayılan seçim olmalı, shared_ptr ancak gerekliyse kullanılmalıdır.

std::weak_ptr

Şüpheli durumda olur: paylaşımlı sahiplik içeren grafiklerde döngüsel referans hafıza sızıntısı yaratır (A, B'yi shared_ptr ile tutar; B de A'yı tutar — ikisi de hiç yıkılmaz). Bu döngüyü kırmak için bir taraf weak_ptr kullanır.

Move Semantics ve Ownership Transfer

C++11'in en önemli eklentilerinden biri move semantics'tir. Move, bir nesnenin kaynağını başka bir nesneye devretmek demektir — kopyalama değil, transfer. Sahiplik bir elden diğerine geçer; eski sahip artık kaynağı tutmaz.

std::unique_ptr<Widget> create() {
    return std::make_unique<Widget>();
}

auto p = create(); // sahiplik fonksiyondan dışarı taşındı

Move olmadan unique_ptr fonksiyondan dönderilemezdi — çünkü kopyalanamaz. Move desteklendiği için sahiplik temiz şekilde aktarılır. Aynı şekilde std::vector büyütülürken iç içerikleri move ederek kopya maliyetini kaldırır. Modern C++ kodu yazarken move semantics farkındalığı performans için kritiktir.

Move sonrası eski nesne "moved-from" durumdadır: hâlâ geçerli ama belirsiz bir değer taşır. Standart genelde "valid but unspecified" der. Moved-from bir nesneye yeni değer atamak güvenlidir; içeriğini okumak değildir.

RAII'nin Yaygın Uygulama Alanları

Smart pointer en görünür örnektir ama RAII çok daha geniş kullanılır. Her kaynak için bir RAII sarmalayıcı yazılabilir.

• Mutex kilitleri: std::lock_guard ve std::unique_lock mutex'i constructor'da kilitler, destructor'da bırakır. Manuel unlock unutma ihtimalini sıfırlar.
• Dosya tanıtıcıları: std::fstream, destructor'ında dosyayı kapatır.
• Thread yaşam süresi: C++20 ile gelen std::jthread, yıkılırken thread'i join eder.
• İşletim sistemi kaynakları: Soket, pipe, paylaşımlı bellek bölgesi — her biri için özel RAII sınıfı yazılır.
• Veritabanı ve API bağlantıları: Connection nesnesi RAII ile yönetilirse connection leak engellenir.
• Geri alma (rollback) işlemleri: Transaction sınıfı, destructor'da commit edilmediyse otomatik rollback yapar — exception güvenli iş akışı sağlar.

RAII desenini öğrenmek ve modern C++'ı pratikte uygulamak isteyenler Modern C++ eğitimi içeriklerinden yararlanabilir; smart pointer'lar, move semantics ve standart kütüphane yapı taşları yapılandırılmış biçimde ele alınır.

Sık Yapılan Hatalar

RAII güçlü bir kavramdır ama yanlış kullanım kapanları vardır:

• Ham pointer'a düşmek: shared_ptr'ın .get() metoduyla ham pointer alıp onu uzun ömürlü saklamak. Sahip olmadığın bir kaynağa sahipmiş gibi davranmak.
• Aynı pointer'ı iki kez sarmak: Aynı ham pointer'dan iki ayrı unique_ptr yapmak. İkisi de yıkıldığında double-free olur.
• shared_ptr'da döngü: A↔B karşılıklı shared_ptr tutması. weak_ptr ile kırılmalı.
• this'i shared_ptr olarak yakalamak: Bir üye fonksiyonun this'i shared_ptr'a dönüştürmesi gerekiyorsa sınıf std::enable_shared_from_this kullanmalıdır; aksi takdirde sayaç bozulur.
• RAII sınıfının kopyalanmasına izin vermek: Bir kaynak sahibi sınıf default kopya constructor'a sahipse iki nesne aynı kaynağa sahip görünür. Genelde kopya devre dışı bırakılır ya da derin kopya yapılır.
• Move sonrası eski nesneyi kullanmak: std::move sonrası kaynak içeren bir nesneye dokunmak tanımsız değildir ama içeriği güvenilmezdir.

RAII'nin Diğer Dillerle Karşılaştırması

Java ve C# garbage collector kullanır; bellek otomatik temizlenir ama dosya ve soket gibi kaynaklar için try-with-resources ya da using bloğu gerekir. Bu yapılar RAII'nin sınırlı bir formudur — çağıran her yerde açıkça yazmak gerekir.

Python'da with bloğu benzer iş görür. Rust ise C++'ın RAII fikrini ileri taşımıştır: ownership ve borrow checker derleyici düzeyinde uygulanır; sahiplik kuralları çalışma zamanında değil, derleme aşamasında garanti edilir. Rust'ın temel tasarım kararı büyük ölçüde C++ RAII deneyiminden öğrenilenler üzerine kuruludur.

C++'ın güçlü tarafı RAII'yi sıfır maliyetle (zero overhead) sağlamasıdır. Smart pointer optimizasyonla ham pointer ile aynı assembly'ye derlenebilir. Bu, sistemin hem güvenli hem hızlı olmasını sağlar — modern C++'ı tercih sebebi yapan ana özelliklerden biridir.

Kaynak yaşam sürelerini öngörülebilir biçimde yönetebilen, exception güvenli kod yazan bir geliştirici, C++'ın getirdiği üretkenlik avantajını gerçekten kullanır. RAII öğrenilmesi tek günlük bir konu değil; ancak aliştığında manuel yönetim düşüncesi tamamen geride bırakılır.