Gösterici (pointer) hatalarının çok büyük bir kısmı sistemden tahsis edilen dinamik alanın geri iadesi kısmında ortaya çıkar. Ya geri iade işlemi unutulur ya da fazladan geri iade işlemi yapılır, ilki de çok fenadır ama ikincisi çok daha fenadır. Geri iade işemi unutulan bir örneğe bakalım.
#include <iostream>
int main()
{
int *pi;
pi = new int;
*pi = 3;
std::cout << "pi : " << *pi << std::endl;
return 0;
}
Yukarıdaki örnekte bir adet int kadar alan ( sizeof(int) ) sistemden tahsis ediliyor. Daha sonra içerisine bir tam sayı atanıyor ve standart çıktıya basılıyor. Fakat bir hata var, tahsis edilen alan delete global operatörü kullanılarak geri bırakılmamış, unutulmuş. Doğrusu şöyle olmalıydı.
#include <iostream>
int main()
{
int *pi;
pi = new int;
*pi = 3;
std::cout << "pi : " << *pi << std::endl;
delete pi;
return 0;
}
Aslında burada pek bir sorun yok gibi. Madem
new ile bir yer tahsis ettik, o zaman
delete ile geri bırakırız ve problem kalmaz. Bu doğru bir söz fakat tasarımın durumuna göre kodun belirli bir bölgesinde tahsis edilen alanın nerede ve ne zaman geri bırakılacağı kodlama zamanını uzatan bir durum. Yanlış noktada geri bırakılan bir bellek bölgesinin tahrifatı büyük olabilir.
Öyle ki bazen hiç bir şey olmaz, bir süre kullanırsınız, daha sonra patlamaya başlar. Kodun ilgili bölümüne artık konsantre olmadığınızdan dolayı böceği yakalamak çok vakit alabilir.
İşte bu durumu ortadan kaldıran akıllı göstericiler uzun zamandır hayatımıza girmiş bulunuyor. Akıllı gösterici kendisine verdiğiniz adresin tuttuğu alanı otomatikman sisteme geri iade eder. Sizin ayrıca
delete ile sisteme geri iade işlemini yapmanıza gerek yoktur. Basit olarak başlangıç fonksiyonunda (constructor) veya atama operatör (assign operator) fonksiyonunda kopyalanan adresin bitiş fonksiyonunda (destructor) otomatikman
delete işlemine sokulmasıdır.
İki çeşit akıllı gösterici tipinden bahsetmek istiyorum.
- Kopyalanamayan akıllı göstericiler
- Kopyalanabilen akıllı göstericiler
Kopyalanamayan akıllı göstericiler kopyalanabilenlerden daha hızlıdırlar. Bununla beraber kullanımları biraz daha sancılıdır. Basit bir örnekle başlayalım. Standard template library (stl) içindeki auto_ptr sınıfını kullanacağız.
#include <iostream>
#include <memory>
int main()
{
std::auto_ptr<int> p1(new int);
*p1.get() = 3;
std::cout << "p1.get() : " << *p1.get() << std::endl;
return 0;
}
Yukarıdaki örnekte herhangi bir delete işlemi yapmadık.
auto_ptr sınıfı otomatikman kendi bitiş (destructor) fonksiyonunda
delete işlemini gerçekleştirdi. Eminiz ki tahsis edilen alan sisteme geri bırakıldı. (Buradaki emin olma duygusu gerçekten çok önemli!)
Bu sınıf içerisindeki adresin başka bir
auto_ptr sınıfına kopyalanamamasının nedeni tahmin edebileceğiniz gibi iki kere delete işlemine otomatikman girmesini engellemek. Eğer kopyalanabilseydi
{
copyable_auto_ptr<int> p1(new int);
copyable_auto_ptr<int> p2(p1)
*p1.get() = 3;
}
blok sonunda hem p1 için hem de p2 için delete işlemi aynı adres üzerinden tahsis edilmiş alanı boşaltmaya çalışacaktı ve böylece patlama gerçekleşecekti.
Peki ben aynı adresi bir yerde değil de birden fazla yerde saklamak ve kullanmak istiyorsam ne olacak?
auto_ptr çözümü güzel ama her zaman efektif değil.
O zaman şu
auto_ptr içerisinde bir sayaç olsa da benim için kaç kopya olduğu bilgisini tutsa, en son kalan kopyanın bitiş (destructor) fonksiyonunda otomatik olarak
delete operatör fonksiyonunu çağırsa ne güzel olurdu değil mi?
Kulağa çok hoş gelen bu özelliği boost kütüphanesinin
shared_ptr sınıfı destekliyor.
Seni seviyorum boost - I love you boost - Я люблю тебя boost
Bu kadar tezahürat yeter sanırım.
Kopyalanabilen akıllı göstericiler kopyalanamayanlara göre daha yavaş olsalar da aynı anda birden çok kopya saklama avantajını ellerinde bulundururlar.
boost kütüphanesinin
shared_ptr sınıfı kendi içerisinde bir sayaç tutar. Her bir kopyalama işleminde bu sayacı bir arttırır ve her bir bitiş (destructor) fonksiyonu çağırıldığında bu sayacı bir azaltır. Sayaç sıfır olduğunda nesnenin artık sisteme geri verimesi gerektiği anlaşılır ve
delete işlemi gerçekleşir. Dolayısı ile her bir
shared_ptr sınıfının bitiş (destructor) fonksiyonunda
delete işlemi yapılmaz, sadece son nesne için yapılır.
#include <iostream>
#include <boost/shared_ptr.hpp>
int main()
{
boost::shared_ptr<int> p1(new int);
*p1 = 3;
boost::shared_ptr<int> p2(p1);
std::cout << "p1 : " << *p1 << std::endl;
std::cout << "p2 : " << *p2 << std::endl;
return 0;
}
Yukarıdaki örnekte
p1 ve
p2 akıllı göstericileri aynı nesnenin adresini gösteriyorlar. İkisi de kullanılabilir. Geri bırakma esnasında
p2 akıllı göstericisinin bitiş (destructor) fonksiyonu daha önce çağırılacaktır (daha sonra yaratıldığı için) ve içerisindeki sayacı bir eksiltecektir.
p1 nesnesinin bitiş fonksiyonu ise önce sayacı bir eksiltecektir sonra sayacı kontrol edecektir. Sayacın değerinin sıfır olduğunu görünce
delete işlemini gerçekleştirecektir.
Java'da bulunan Garbage Collector sistemi gibi güvenilir ama ne zaman silineceği belli olan (Java'da Garbage Collector'ün ne zaman
delete işlemini yapacağını bilmiyoruz) harika bir sistem.
Hata Nesneleri ile Akıllı Göstericiler
Akıllı göstericilerin bir güzel özelliği de hata nesnesi oluşumunda ortaya çıkar. Bir hata oluştuğunda fonksiyon bitmeden yukarı doğru
throw işlemi gerçekleşir.
detele işleminiz fonksiyonun sonunda ise ilgili kod kısmını try - catch bloğuna almanız, throw'u yakalamanız ve dinamik bölgeyi
delete işlemine soktukran sonra mevcut
throw işemini yukarı göndermeniz gerekir. Bunu yapmazsanız aşağıdaki gibi bir durum oluşur.
#include <iostream>
void a_func_send_throw()
{
throw 20;
}
int main()
{
int *pi;
pi = new int;
*pi = 3;
a_func_send_throw();
std::cout << "pi : " << *pi << std::endl;
delete pi;
return 0;
}
a_func_send_throw fonksiyonu throw işlemini gerçekleştiriyor ve
delete işlemi gerçekleşmiyor. Kodun akış yönü a_func_send_throw fonksiyonun gönderdiği
throw sayesinde değişiyor. Şöyle yapabilirdik.
#include <iostream>
void a_func_send_throw()
{
throw 20;
}
int main()
{
int *pi;
pi = new int;
*pi = 3;
try {
a_func_send_throw();
} catch (int e) {
delete pi;
return 0;
}
std::cout << "pi : " << *pi << std::endl;
delete pi;
return 0;
}
Görüldüğü gibi bu çok sancılı bir yöntem. Her türlü kontrol için bir sürü işlem yapmanız gerekiyor.
C++'ın bir özelliği
throw anında mevcuttaki nesnelerin bitiş (destructor) fonksiyonlarının çağırılmasıdır. Böylece throw işlemi yukarı doğru tırmanmadan nesnenizin bitiş fonksiyonu çağırılarak delete işlemi otomatik olarak gerçekleştirilir.
#include <iostream>
#include <boost/shared_ptr.hpp>
void a_func_send_throw()
{
throw 20;
}
int main()
{
boost::shared_ptr<int> pi(new int);
*pi = 3;
a_func_send_throw();
std::cout << "pi : " << *pi << std::endl;
return 0;
}
Artik dinamik olarak tahsis edilmiş alanımızın throw anında dahi sisteme iade edildiğinden eminiz.
boost kütüphanesinin
shared_array sınıfı aynı
shared_ptr gibidir fakat tek farkı
new operatör fonksiyonu yerine
new [] operatör fonksiyonunu kullanır ve bitiş (destructor) fonksiyonu içerisinde
delete operatör fonksiyonu yerine
delete [] operatör fonksiyonu çağırılır.
boost kütüphanesinin
scoped_ptr sınıfı da vardır. Bu sınıf aynı stl kütüphanesinin
auto_ptr sınıfı gibidir. Yani içerisinde sayaç yoktur. Eğer
new yerine
new [] kullanmak isterseniz
scoped_array size yardımcı olacaktır.
Bu güzel göstericileri bol bol kullanacağınız mutlu kodlamalı günler dilerim :)
Volkan Özyılmaz
