STL Algoritmaları
STL (Standard Template Library) Algoritmaları, C++ programlama dilinde veri yapıları üzerinde çeşitli işlemleri gerçekleştirmek için kullanılan önceden tanımlanmış fonksiyonlardır. Bu algoritmalar, sıralama, arama, dönüştürme, birleştirme ve biriktirme gibi yaygın veri manipülasyonu işlemlerini standart ve güvenli bir şekilde gerçekleştirir. STL algoritmaları, kod tekrarını azaltır, bakım kolaylığı sağlar ve programın performansını artırır.
C++ geliştirme sürecinde STL algoritmaları, vektörler, listeler, setler ve mapler gibi kapsayıcılar üzerinde operasyon yapmak için yaygın olarak kullanılır. Bu algoritmalar, iteratörler, lambda ifadeleri, fonksiyon nesneleri ve OOP prensipleriyle entegre olarak yazılımın daha modüler ve ölçeklenebilir olmasını sağlar.
Bu eğitimde okuyucu, std::sort, std::find_if, std::for_each, std::accumulate ve std::transform gibi temel STL algoritmalarını öğrenerek, pratik problemlere uygulayabilecek ve yüksek kaliteli, güvenli C++ kodu yazma becerisi kazanacaktır. Ayrıca algoritmaların performans optimizasyonları ve hata yönetimi gibi ileri seviye konular da ele alınacaktır.
Temel Örnek
text\#include <iostream>
\#include <vector>
\#include <algorithm>
\#include <numeric>
int main() {
std::vector<int> sayilar = {10, 5, 20, 15, 30};
// Sıralama
std::sort(sayilar.begin(), sayilar.end());
// Yazdırma
std::for_each(sayilar.begin(), sayilar.end(), [](int n){
std::cout << n << " ";
});
std::cout << std::endl;
// 15'ten büyük ilk sayıyı bulma
auto it = std::find_if(sayilar.begin(), sayilar.end(), [](int n){ return n > 15; });
if(it != sayilar.end()) {
std::cout << "15'ten büyük ilk sayı: " << *it << std::endl;
}
// Tüm elemanların toplamı
int toplam = std::accumulate(sayilar.begin(), sayilar.end(), 0);
std::cout << "Elemanların toplamı: " << toplam << std::endl;
return 0;
}Bu örnekte, std::sort fonksiyonu vektör elemanlarını küçükten büyüğe sıralar. std::for_each, lambda ifadesi ile tüm elemanları yazdırır. std::find_if, belirtilen koşulu sağlayan ilk elemanı bulur ve std::accumulate, tüm elemanların toplamını hesaplar.
STL algoritmaları, iteratörler ve lambda ifadeleri ile birleştiğinde, herhangi bir kapsayıcı üzerinde tekrar kullanılabilir ve güvenli bir şekilde çalışabilir. Bu yöntem, projelerde kod tekrarını azaltır, okunabilirliği artırır ve performans optimizasyonunu destekler.
Pratik Örnek
text\#include <iostream>
\#include <vector>
\#include <algorithm>
\#include <numeric>
class Urun {
public:
std::string ad;
double fiyat;
Urun(std::string a, double f) : ad(a), fiyat(f) {}
};
int main() {
std::vector<Urun> envanter = {
{"Laptop", 1200.0},
{"Telefon", 800.0},
{"Tablet", 450.0},
{"Monitör", 300.0}
};
// Fiyata göre sıralama
std::sort(envanter.begin(), envanter.end(), [](const Urun &a, const Urun &b){
return a.fiyat < b.fiyat;
});
// Fiyatları %10 artırma
std::for_each(envanter.begin(), envanter.end(), [](Urun &u){
u.fiyat *= 1.10;
});
// Toplam değer hesaplama
double toplamDeger = std::accumulate(envanter.begin(), envanter.end(), 0.0, [](double toplam, const Urun &u){
return toplam + u.fiyat;
});
// Yazdırma
for(const auto &u : envanter) {
std::cout << u.ad << ": $" << u.fiyat << std::endl;
}
std::cout << "Toplam değer: $" << toplamDeger << std::endl;
return 0;
}Bu pratik örnek, STL algoritmalarının OOP ile entegrasyonunu gösterir. Urun sınıfı veri ve davranışları kapsüller. std::sort ile fiyat sıralaması, std::for_each ile fiyat güncelleme ve std::accumulate ile toplam değer hesaplanır. Lambda ifadeleri ve const correctness kullanımı kodun güvenliğini, okunabilirliğini ve performansını artırır.
STL algoritmalarında en iyi uygulamalar arasında iteratör ve lambda kullanımı, const correctness ile kopya oluşturmadan işlem yapma ve uygun algoritmaların seçimi bulunur. Yaygın hatalar arasında iteratör hataları, bellek yönetim sorunları ve verimsiz algoritmalar yer alır. Optimizasyon için algoritmaların ön koşullarını doğrulamak, stable_sort veya lower_bound gibi alternatifleri değerlendirmek ve hata kontrolünü sağlamak önemlidir.
📊 Referans Tablosu
| C++ Element/Concept | Description | Usage Example |
|---|---|---|
| std::sort | Elemanları sıralar | std::sort(vec.begin(), vec.end()); |
| std::for_each | Tüm elemanlara fonksiyon uygular | std::for_each(vec.begin(), vec.end(), \[]\(int n){ std::cout << n; }); |
| std::find_if | Koşulu sağlayan ilk elemanı bulur | auto it = std::find_if(vec.begin(), vec.end(), \[]\(int n){ return n>10; }); |
| std::accumulate | Elemanları toplar veya birleştirir | int toplam = std::accumulate(vec.begin(), vec.end(), 0); |
| std::transform | Elemanları dönüştürür | std::transform(vec.begin(), vec.end(), vec.begin(), \[]\(int n){ return n*2; }); |
STL algoritmaları, güvenli ve verimli veri manipülasyonu sağlar, kod tekrarını azaltır ve bakım kolaylığı sunar. Anahtar kavramlar iteratörler, lambda ifadeleri ve OOP ile entegrasyondur. İleri seviyede stable_sort, paralel algoritmalar ve gelişmiş pipeline tekniklerini öğrenmek, STL algoritmalarında ustalaşmak için önerilen sonraki adımlardır.
🧠 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