C++ Akıllı İşaretçiler: unique_ptr ve shared_ptr Açıklaması

Akıllı İşaretçilerin Çözdüğü Sorun

Önceki sayfada belleği new ile ayırdın ve delete ile serbest bıraktın. Bu işe yarar, ama yükü sana yükler: her new'in karşılık gelen bir delete'e ihtiyacı vardır; bu, kodun her yolunda, hatta yarı yolda bir istisnanın fırlatıldığı yollarda bile geçerlidir. Birini kaçırırsan bellek sızdırırsın; delete'i iki kez çalıştırırsan heap'i bozarsın.

Akıllı işaretçiler bunu, heap belleğinin ömrünü yığındaki normal bir nesneye bağlayarak çözer. O nesne kapsam dışına çıktığında, yıkıcısı senin yerine delete'i çalıştırır; bir istisna yığını geri sarsa bile bu garantilidir. Bu fikre RAII (Resource Acquisition Is Initialization) denir ve akıllı işaretçiler <memory> başlığında bulunur.

#include <iostream>
#include <memory>
using namespace std;

int main() {
    unique_ptr<int> p = make_unique<int>(42);

    cout << *p << "\n";   // normal bir işaretçi gibi referans çöz: 42

    // delete gerekmez. p burada kapsam dışına çıktığında,
    // int otomatik olarak serbest bırakılır.
    return 0;
}

*p ve p->member'i tıpkı bir ham işaretçide olduğu gibi kullanırsın. Fark, asla delete çağırmamandır; bunu akıllı işaretçi yapar.

unique_ptr: Tek Sahip, Paylaşım Yok

unique_ptr, varsayılan olarak başvurman gereken akıllı işaretçidir. Münhasır sahipliği temsil eder: her an nesneye tam olarak bir unique_ptr sahiptir ve o işaretçi öldüğünde nesne de onunla birlikte ölür. Ham bir işaretçiye kıyasla sıfır çalışma zamanı maliyeti vardır.

Bir tane oluşturmak için make_unique (C++14) kullan. Yapıcının argümanlarını alır ve sana kullanıma hazır bir işaretçi verir:

#include <iostream>
#include <memory>
#include <string>
using namespace std;

struct User {
    string name;
    int age;
    User(string n, int a) : name(n), age(a) {}
};

int main() {
    auto user = make_unique<User>("Ada", 36);

    cout << user->name << " is " << user->age << "\n";  // Ada is 36
    return 0;
}

Yalnızca bir sahip olabileceği için bir unique_ptr kopyalanamaz. Onu kopyalamaya çalışmak bir derleme hatasıdır ve bu hata, dilin seni iki sahibin aynı nesneyi delete etmeye çalışmasından koruyor olmasıdır:

auto a = make_unique<int>(10);
auto b = a;   // error: call to deleted copy constructor of unique_ptr

Sahipliği başkasına devretmek için onu std::move ile taşırsın. Taşımadan sonra orijinal işaretçi boş kalır (nullptr tutar):

#include <iostream>
#include <memory>
#include <utility>
using namespace std;

int main() {
    auto a = make_unique<int>(10);
    auto b = move(a);   // sahiplik a'dan b'ye aktarılır

    if (!a) cout << "a is now empty\n";
    cout << "b owns " << *b << "\n";   // b owns 10
    return 0;
}

Çoğu zaman isteyeceğin model budur: her zaman tam olarak bir net sahip vardır ve derleyici bunu zorunlu kılar.

shared_ptr: Referans Sayımıyla Paylaşılan Sahiplik

Bazen programının birkaç parçasının gerçekten aynı nesneyi paylaşması gerekir ve hiçbiri en son hangisinin biteceğini bilmez. İşte shared_ptr bunun içindir. Bir referans sayısı tutar: her kopya sayıyı artırır, her yıkım azaltır ve nesne yalnızca sayı sıfıra ulaştığında serbest bırakılır.

Bunları make_shared ile oluştur:

#include <iostream>
#include <memory>
using namespace std;

int main() {
    auto a = make_shared<int>(99);
    cout << "count: " << a.use_count() << "\n";  // 1

    {
        auto b = a;   // kopyalamaya izin verilir - ikisi de int'i paylaşır
        cout << "count: " << a.use_count() << "\n";  // 2
    }   // b burada ölür, sayı tekrar 1'e düşer

    cout << "count: " << a.use_count() << "\n";  // 1
    return 0;
}

unique_ptr'in aksine, bir shared_ptr'i kopyalamak sorun değildir; zaten bütün mesele budur. Bunun bedeli maliyettir: referans sayısı heap üzerinde saklanır ve atomik olarak (iş parçacığı güvenli) güncellenir, bu yüzden shared_ptr, unique_ptr'den daha ağırdır. Yalnızca sahiplik gerçekten paylaşıldığında ona başvur; neyin sahibinin kim olduğunu düşünmekten kaçınmak için değil.

make_shared ayrıca shared_ptr<T>(new T(...))'dan daha verimlidir: nesneyi ve kontrol bloğunu iki yerine tek bir ayırmada tahsis eder.

weak_ptr ve Referans Döngülerini Kırmak

shared_ptr'in klasik bir tuzağı vardır: eğer iki nesne birbirine shared_ptr tutuyorsa, referans sayıları asla sıfıra ulaşmaz, dolayısıyla hiçbiri serbest bırakılmaz; akıllı işaretçiler kullanmana rağmen bir bellek sızıntısı.

struct Node {
    shared_ptr<Node> next;   // iki düğüm birbirini gösterirse,
};                           // birbirlerini sonsuza kadar canlı tutarlar

Çözüm weak_ptr'dir: bir shared_ptr'in sahip olmayan bir gözlemcisi. Referans sayısını artırmaz, bu yüzden asla bir nesneyi canlı tutmaz. Nesneyi kullanmak için .lock() çağırırsın; bu, nesne hâlâ varsa sana bir shared_ptr, çoktan gitmişse boş bir tane verir.

#include <iostream>
#include <memory>
using namespace std;

int main() {
    auto strong = make_shared<int>(7);
    weak_ptr<int> observer = strong;   // sayıyı artırmaz

    cout << "count: " << strong.use_count() << "\n";  // hâlâ 1

    if (auto locked = observer.lock()) {   // güvenli şekilde shared_ptr'e yükselt
        cout << "still alive: " << *locked << "\n";
    }

    strong.reset();   // nesne şimdi serbest bırakılır

    if (observer.expired()) cout << "object is gone\n";
    return 0;
}

weak_ptr'i "geri işaretçiler" ve önbellekler için kullan; bir nesnenin sahipliğini iddia etmeden ona referans vermek istediğin her yer için.

Sık Yapılan Hatalar ve Tuzaklar

Akıllı işaretçiler bellek hatalarının çoğunu ortadan kaldırır, ama birkaç tuzak kalır:

Aynı belleğin akıllı ve ham sahipliğini karıştırma. Aynı ham işaretçiden asla iki akıllı işaretçi oluşturma; her biri onu delete etmeye çalışacaktır:

int* raw = new int(5);
unique_ptr<int> a(raw);
unique_ptr<int> b(raw);   // felaket: ikisi de aynı int'i siler (çift serbest bırakma)

İşte bu yüzden make_unique/make_shared'i tercih edersin; yanlış kullanılacak başıboş bir ham işaretçi olmaz.

Bir unique_ptr yalnızca taşınabilir, bu yüzden sahipliği devretmek için onu değere göre geçir. Bir fonksiyon nesneyi kullanmalı ama sahiplenmemeli ise, bunun yerine düz bir referans veya ham bir T* al; yalnızca gözlemleyen ham bir işaretçi gayet uygundur:

void consume(unique_ptr<int> p);   // sahipliği alır (içine taşı)
void observe(int* p);              // sadece bakar, hiçbir şeye sahip olmaz

Varsayılan olarak shared_ptr'e başvurma. Serbestçe kopyalandığı için cazip gelir, ama atomik referans sayımı gerçek performans maliyetine yol açar ve paylaşılan sahiplik ömürler üzerine akıl yürütmeyi zorlaştırır. Varsayılanın unique_ptr olsun; yalnızca gerçekten birden çok sahip gerektiğinde shared_ptr'e yükselt.

Diziler için unique_ptr'in dizi biçimine ihtiyacı vardır. make_unique<int[]>(n), sana delete[]'i doğru şekilde çağıran bir unique_ptr<int[]> verir. Pratikte, dinamik diziler için std::vector'ı tercih et; belleği senin yerine yönetir ve üstüne boyut takibi sağlar.

Sonraki: Stringler

Artık bellek yönetimi kontrol altında: akıllı işaretçiler sana sızıntılar olmadan heap ayırma verir. Ayırıp ortalıkta dolaştıracağın en yaygın şeylerden biri metindir ve C++ sana ham char* tamponlarından çok daha güvenli bir araç sunar. Sonraki sayfa std::string'i ele alır: kendi kendine nasıl büyüdüğünü, her gün kullanacağın işlemleri ve seni manuel bellek işinden tamamen nasıl kurtardığını.