Akıllı Pointerlar
Akıllı Pointerlar, C++’ta bellek yönetimini otomatikleştiren ve programcılara güvenli bir şekilde kaynakları yönetme imkanı sağlayan özel sınıflardır. Geleneksel ham pointer’ların aksine, akıllı pointerlar kullanıldıktan sonra bellek sızıntılarını önler ve kaynakların yaşam döngüsünü yönetir. En yaygın türleri unique_ptr (tek sahiplik), shared_ptr (paylaşılan sahiplik) ve weak_ptr (zayıf referans) olarak sınıflandırılır.
Akıllı pointerlar, özellikle modern C++ projelerinde, yüksek güvenlik ve performans gerektiren durumlarda kullanılır. Unique_ptr, tek bir nesnenin sahipliğini garanti ederken, shared_ptr bir nesneyi birden fazla pointer arasında paylaşmayı sağlar. Weak_ptr ise shared_ptr ile oluşabilecek referans döngülerini önlemek için kullanılır. Bu yapıların doğru kullanımı, veri yapıları, algoritmalar ve OOP prensipleri ile entegre edilerek yazılımın güvenilirliğini ve sürdürülebilirliğini artırır.
Bu eğitim içeriğinde, unique_ptr, shared_ptr ve weak_ptr’in kullanımıyla ilgili gerçek dünya örnekleri sunulacak, STL ve algoritmalarla entegrasyonu gösterilecek ve akıllı pointerlar kullanılarak bellek yönetimi ve performans optimizasyonu konuları detaylı şekilde ele alınacaktır. Öğrenciler, akıllı pointerları efektif kullanarak C++ projelerinde daha güvenli, temiz ve hatasız kod yazmayı öğreneceklerdir.
Temel Örnek
text\#include <iostream>
\#include <memory>
\#include <string>
class Calisan {
public:
Calisan(const std::string& isim) : isim_(isim) {
std::cout << "Çalışan " << isim_ << " oluşturuldu.\n";
}
\~Calisan() {
std::cout << "Çalışan " << isim_ << " silindi.\n";
}
void goster() const {
std::cout << "İsim: " << isim_ << "\n";
}
private:
std::string isim_;
};
int main() {
std::unique_ptr<Calisan> c1 = std::make_unique<Calisan>("Ahmet");
c1->goster();
std::shared_ptr<Calisan> c2 = std::make_shared<Calisan>("Ayşe");
std::shared_ptr<Calisan> c3 = c2;
c2->goster();
c3->goster();
std::weak_ptr<Calisan> cZayif = c2;
if (auto cKilitle = cZayif.lock()) {
cKilitle->goster();
}
return 0;
}Yukarıdaki örnekte, Calisan sınıfı bir constructor, destructor ve goster metodu içerir. unique_ptr, "Ahmet" nesnesi için tek sahipliği sağlar ve bellek yönetimini otomatik yapar. shared_ptr, "Ayşe" nesnesi için birden fazla pointer tarafından paylaşılabilen sahipliği yönetir. weak_ptr, shared_ptr ile oluşturulan nesneye zayıf referans sağlar ve referans döngüsünü önler. lock() metodu ile nesnenin geçerliliği kontrol edilir. Bu yapı, bellek sızıntılarını önler, kaynakların yaşam döngüsünü güvenli bir şekilde yönetir ve STL ile entegrasyonu gösterir.
Pratik Örnek
text\#include <iostream>
\#include <memory>
\#include <vector>
\#include <algorithm>
class Gorev {
public:
Gorev(int id) : id_(id) {
std::cout << "Görev " << id_ << " oluşturuldu.\n";
}
\~Gorev() {
std::cout << "Görev " << id_ << " silindi.\n";
}
void calistir() const {
std::cout << "Görev " << id_ << " çalıştırılıyor.\n";
}
private:
int id_;
};
int main() {
std::vector\<std::shared_ptr<Gorev>> gorevListesi;
for (int i = 1; i <= 5; ++i) {
gorevListesi.push_back(std::make_shared<Gorev>(i));
}
std::for_each(gorevListesi.begin(), gorevListesi.end(), [](const std::shared_ptr<Gorev>& g){
g->calistir();
});
gorevListesi.clear();
return 0;
}Bu örnek, akıllı pointerların pratik kullanımını gösterir. Gorev sınıfı shared_ptr ile bir vector içine yerleştirilir ve std::for_each ile çalıştırılır. Vector temizlendiğinde tüm nesneler otomatik olarak silinir. Bu yöntem, pointer yönetimini güvenli hale getirir, memory leak riskini azaltır, STL ve algoritmalarla sorunsuz entegrasyon sağlar ve C++ projelerinde kaynak yönetimini kolaylaştırır.
Akıllı pointerlar için en iyi uygulamalar; unique_ptr ile tek sahiplik, shared_ptr ile paylaşılan sahiplik ve weak_ptr ile referans döngülerini önlemektir. unique_ptr kopyalanamaz ve std::move ile transfer edilir. shared_ptr referans sayacı nedeniyle hafif ek yük oluşturur, bu yüzden mümkün olduğunda unique_ptr tercih edilmelidir. weak_ptr.lock() ile nesne geçerliliği kontrol edilir. Nesnelerin yaşam döngüsü ve sahipliği net bir şekilde yönetilmeli, pointerlar geçersiz belleğe erişmemelidir.
📊 Referans Tablosu
| C++ Element/Concept | Description | Usage Example |
|---|---|---|
| unique_ptr | Tek sahiplik ve otomatik bellek yönetimi | std::unique_ptr<Calisan> c = std::make_unique<Calisan>("Ahmet"); |
| shared_ptr | Paylaşılan sahiplik ve referans sayacı | std::shared_ptr<Calisan> c1 = std::make_shared<Calisan>("Ayşe"); std::shared_ptr<Calisan> c2 = c1; |
| weak_ptr | Zayıf referans, referans döngüsünü önler | std::weak_ptr<Calisan> w = c1; if(auto l = w\.lock()){ l->goster(); } |
| std::make_unique | Unique_ptr güvenli oluşturma | auto ptr = std::make_unique<Gorev>(1); |
| std::make_shared | Shared_ptr verimli oluşturma | auto ptr = std::make_shared<Gorev>(2); |
Akıllı pointerları öğrenmek, bellek yönetimini güvenli ve verimli hale getirir, kodun bakımını ve güvenliğini artırır. unique_ptr, shared_ptr ve weak_ptr’in etkin kullanımı, STL ve algoritmalarla entegrasyon, ileri C++ projelerinde kritik bir beceridir. Sonraki adımlar RAII, dinamik bellek yönetimi ve multi-threading ile akıllı pointer kullanımını incelemek olmalıdır. Resmi C++ dokümantasyonu, kaynak kitaplar ve açık kaynak projeler bu öğrenimi destekler.
🧠 Bilginizi Test Edin
Test Your Knowledge
Test your understanding of this topic with practical questions.
📝 Talimatlar
- Her soruyu dikkatle okuyun
- Her soru için en iyi cevabı seçin
- Quiz'i istediğiniz kadar tekrar alabilirsiniz
- İlerlemeniz üstte gösterilecek