Akıllı işaretçiler arasında en güçlü özelliklere sahip olan boost::shared_ptr<>‘den bahsetmeye geldi sıra. Bu işaretçi sayesinde en zorlu bellek yönetim ve nesne ömrü problemlerini çözebiliyoruz.

shared_ptr, daha önce bahsettiğimiz scoped_ptr ve auto_ptr’ye temelde benziyor. Yine amacı bir nesneye işaret etmek ve doğru zamanda nesneyi silmek. Ancak diğer iki akıllı işaretçide olan bir nesneye yalnız bir işaretçinin “sahip” olması zorunluluğu yok. Aksine shared_ptr’leri kullanarak bir nesneyi birden fazla işaretçinin sahipliğine veya paylaşımına verebiliyoruz. Başka bir deyişle bir grup shared_ptr aynı nesneyi paylaşıyor ve paylaşan bütün işaretçiler ortadan kalktığında, nesne de siliniyor. Bu paylaşım kopyalama/atama yoluyla oluyor.

 
boost::shared_ptr<T> Yonetici::YeniTYarat(){
    boost::shared_ptr<T> p1( new T() );
    this->mKayitListesi.push_back( p1 );
    return p1;
}

void App::hede(){
    boost::shared_ptr<T> p = mYonetici->YeniTYarat();
    ...
    // p ile birseyler yap
    ...
}

Mesela bu örnekte önce YeniTYarat metodunun içinde p1 işaretçisi objeye bakan ilk işaretçi oluyor. Ardından p1’in bir kopyası bir vector kabına atılıyor. Yani artık iki sahip var. Biri p1, digeri de vectör’ün içindeki işaretçi. Sonra metoddan dönülürken, p1 geçici bir değişkene atanıyor (3. sahip ortaya çıkıyor) ve hemen ardından p1’in ömrü doluyor (kapsam sonuna gelindiği için). Bunun ardından hede metodunun kapsamı içinde isimsiz geçici işaretçi, p işaretçisine atanıyor (bu noktada geçici isimsiz işaretçinin ömrünün dolduğunu varsayabiliriz). Artık bu anda yine iki sahip var. Biri hede kapsamındaki p, diğeri mYönetici nesnesinin içindeki vektörde bulunan işaretçi. Hede metodundan çıkılırken de p yok oluyor ve tek sahip kalıyor. Eğer programın ilerleyen aşamalarında mYönetici nesnesi herhangi bir sebeple silinirse (ve en başta yarattığımız T nesnesine bakan başka shared_ptr yaratılmadıysa), o esnada vektörün içindeki shared_ptr’nin yıkıcı metodu T nesnesini silecek.

Görüldüğü gibi, bu şekilde shared_ptr’ler kullanarak nesnelerin sahipliğini istediğiniz kadar çok sayıda yere bölüştürebilir ve hiçbir zaman elinizdeki hiçbir shared_ptr’nin sallantıya düşmeyeceğinden (silinmiş bir nesneye bakmayacağından) emin olabilirsiniz.

shared_ptr’ler yukarıdaki örnekte görebileceğiniz gibi STL kapları ile kullanılmaya uygundurlar. Hatta karşılaştırma operatörleri de tanımlı olduğu için, ilişkisel kaplarda (associative container) yani std::map ve std::set gibi kaplarda da kullanılabilirler.

shared_ptr kullanırken dikkat etmeniz gereken iki kritik nokta var

Birincisi birden fazla argüman alan metodlara shared_ptr geçirirken, her zaman isimli bir shared_ptr kullanmak. Mesela elimizde soyle iki metod olsun

 
int g();
void f( boost::shared_ptr<T>, int );

Daha sonra bunları şöyle kullandığımızı düşünelim.

 
boost::shared_ptr<T> p( new T() );
f( p, g() );

Bu kullanım yukarıda bahsettiğimiz kurala uyuyor. Aynı kodu aşağıdaki gibi yazmamız ise sakıncalı:

 
f( boost::shared_ptr<T>(new T() ), g() );

Buradaki problem şu. C++ standardı bu şekilde yazılan bir kodda new T(), g() ve shared_ptr yapıcısının hangi sırada çağırılacağını tanımlamamıştır. Yani bu kod çalışırken, bu bahsettiğimiz üç parça herhangi bir sırada çalışabilir. Dolayısıyla eger önce new çalışır, ardından g() çalışır ve en son shared_ptr yapıcısı çalışırsa sızıntı tehlikesi vardır. Bu senaryoda eğer g() istisna tetiklerse henüz shared_ptr yaratılmadığı ve kapsamdan çıkılırken yıkıcısı çağırılmayacağı için, new ile alınan T nesnesi sızdırılmış olur.

Bu uyarıyı tam anlamamış olabilirsiniz. İstisna güvenliği konusu derin bir konu ve o konuda daha sonra yazacağım. Ancak siz anlamadıysanız bile, birden fazla argüman alan metodlara shared_ptr geçirirken bu şekilde satır tasarrufu yapmaya çalışmayın.

İkinci uyarı noktası ise nesneler arası döngüsel shared_ptr kullanım problemi. Mesela T cinsinden iki nesnemiz olsun. t1 ve t2 diyelim. T sınıfının üye değişkenlerinden biri de shared_ptr<T> tipine sahip olsun.

 
class T{
public:
    boost::shared_ptr<T> p;
};

void hede(){
    boost::shared_ptr<T> t1( new T() );
    boost::shared_ptr<T> t2( new T() );

    ....

    t1->p = t2;
    t2->p = t1;
}

Burada bir şekilde kodda t1 ve t2 nesneleri birbirlerine bakan bir shared_ptr’ye sahip olmuş durumda. Yani bir işaretçi döngüsü oluşmuş. Bu durumda bir problem oluyor. Dikkat ederseniz biribirine bakan böyle iki nesne olduğu zaman, dışarıdan bu nesnelere bakan bütün shared_ptr’ler silinse bile, bu iki nesnenin içlerindeki shared_ptr’ler kaldığı sürece nesneler silinmiyor. Başka bir deyişle iki nesne birbirini hayatta tutuyor. Örneğin yukarıdaki kodda hede metodundan çıkıldığında t1 ve t2 işaretçileri yok olacak ve bizim elimizde bu iki nesneye bakan bir işaretçi kalmayacak. Bu da bir nevi sızıntı.

İşte shared_ptr’ler böyle döngüsel kullanıma uygun olmadıkları için bu durumlarda döngüleri kırmak için weak_ptr adı verilen boost işaretçilerini kullanıyoruz. Bu da gelecek yazının konusu.

Share

Comments

  1. Savaş Akgöl on 02.08.2010

    Bilgem merhaba,

    İşimde Java programlama dilini kullanıyorum. C++ hobimdir. Boost kütüphanesini ben de kullanmaya çalışıyorum. Template metaprogramming konseptini öğrenmeye çalışıyorum.

    Bu güne kadar hep yabancı siteleri ve blogları takip ettim. Türk olupta okuduğum ve gerçekten beğendim ilk blog. Takdir ediyorum.

    Hergün bakındığım şu site var benim, belki ilgini çeker diye yolluyorum.

    http://www.viksoe.dk/code/all_news.htm

    Kolay gelsin
    Saygılarımla

  2. Alper Kartal on 07.06.2011

    c/c++ dilinde çok yeni birisi olarak pek fazla bir şey söyleyemeyeceğim fakat takip ettiklerim arasında en iyisi diyebilirim.Bu işin sadece bir meslek olmadığını düşünen birisi olarak takip etmeye çalışacağımı söylemek isterim.Çalışmalarında başarılar dilerim.

  3. özgür on 09.06.2011

    c++ dilinde yeni birisi olarak anlatımlarını çok açıklayıcı ve faydalı buluyorum.Tek bir rica olarak anlattığın konuların sonuna konu ile ilgili örnek koyabilirsen daha çok pekiştirilmiş olacak.Paylaşımlar için teşekkür ederim.

Leave a Reply