• Konteynerler (Containers): Veri depolamak için kullanılan nesnelerdir. Farklı veri depolama gereksinimlerine göre optimize edilmiş çeşitli türleri vardır.
• İteratörler (Iterators): Konteynerlerdeki elemanlara erişmek ve onlar üzerinde gezinmek için soyut bir arayüz sağlarlar. Algoritmaların konteynerlerden bağımsız çalışmasını sağlayan "tutkal" olarak düşünülebilirler.
• Algoritmalar (Algorithms): Konteynerler üzerindeki belirli işlemleri (arama, sıralama, kopyalama, dönüştürme vb.) gerçekleştiren fonksiyonlardır. İteratörler aracılığıyla konteynerdeki verilere erişirler.
• Fonksiyon Nesneleri (Function Objects / Functors): Fonksiyon gibi çağrılabilecek nesnelerdir. Algoritmalara özelleştirilmiş davranışlar eklemek için kullanılırlar. C++11 sonrası lambda ifadeleriyle kullanımları daha da kolaylaşmıştır.
• Adaptörler (Adapters): Mevcut konteynerlerin veya fonksiyon nesnelerinin arayüzlerini değiştirerek farklı bir davranış sergilemelerini sağlayan yapılardır. Örneğin, bir listeyi bir yığın (stack) gibi kullanmak için konteyner adaptörleri kullanılır.

• Sıralı Konteynerler (Sequence Containers): Elemanların eklendiği sırayı korurlar. Örnekler: std::vector (dinamik dizi), std::list (çift bağlı liste), std::deque (çift uçlu kuyruk).
• İlişkisel Konteynerler (Associative Containers): Elemanları sıralı veya anahtara göre depolarlar. Arama, ekleme ve silme işlemleri genellikle logaritmik zamanda (O(log n)) gerçekleşir. Örnekler: std::set (benzersiz sıralı elemanlar), std::map (anahtar-değer çiftleri), std::multiset, std::multimap.
• Sırasız Konteynerler (Unordered Containers) - C++11 ve sonrası: Elemanları hash tabanlı depolarlar. Arama, ekleme ve silme işlemleri ortalama sabit zamanda (O(1)) gerçekleşir. Örnekler: std::unordered_set, std::unordered_map.

#include <vector>
#include <map>
#include <string>
#include <iostream>

int main() {
    // std::vector kullanımı
    std::vector<int> sayilar = {10, 20, 30, 40, 50};
    sayilar.push_back(60);
    std::cout << "Vector elemanlari: ";
    for (int sayi : sayilar) {
        std::cout << sayi << " ";
    }
    std::cout << std::endl;

    // std::map kullanımı
    std::map<std::string, int> yaslar;
    yaslar["Ahmet"] = 30;
    yaslar["Ayse"] = 25;
    yaslar.insert({"Mehmet", 35});

    std::cout << "Map elemanlari: ";
    for (const auto& cift : yaslar) {
        std::cout << cift.first << ": " << cift.second << " ";
    }
    std::cout << std::endl;

    return 0;
}

• Input Iterators: Tek geçişli, sadece okunabilir.
• Output Iterators: Tek geçişli, sadece yazılabilir.
• Forward Iterators: İleriye doğru hareket edebilir, çoklu geçişli, okunabilir/yazılabilir.
• Bidirectional Iterators: İleri ve geri hareket edebilir, çoklu geçişli, okunabilir/yazılabilir. std::list ve std::map iteratörleri bu türdendir.
• Random Access Iterators: Herhangi bir elemana doğrudan erişebilir (pointer aritmetiği gibi), ileri ve geri hareket edebilir. std::vector ve std::deque iteratörleri bu türdendir.

#include <vector>
#include <iostream>

int main() {
    std::vector<int> data = {1, 2, 3, 4, 5};

    // begin() ve end() ile iteratörler
    for (std::vector<int>::iterator it = data.begin(); it != data.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // C++11 range-based for döngüsü (iteratörleri arka planda kullanır)
    for (int val : data) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

"İteratörler, STL'nin gücünün temelini oluşturur. Konteynerler ile algoritmalar arasındaki soyutlamayı sağlayarak esneklik ve yeniden kullanılabilirlik sunarlar."

Genişletmek için tıkla ...

• std::sort: Bir aralıktaki elemanları sıralar.
• std::find: Bir aralıkta belirli bir değeri arar.
• std::for_each: Bir aralıktaki her elemana bir işlem uygular.
• std::transform: Bir aralıktaki elemanları dönüştürerek başka bir aralığa kopyalar.
• std::copy: Bir aralıktaki elemanları başka bir aralığa kopyalar.
• std::accumulate: Bir aralıktaki elemanların toplamını hesaplar (numeric başlığında).

#include <vector>
#include <algorithm> // sort, find için
#include <iostream>

int main() {
    std::vector<int> numbers = {5, 2, 8, 1, 9, 4};

    // std::sort kullanımı
    std::sort(numbers.begin(), numbers.end());
    std::cout << "Siralanmis vector: ";
    for (int n : numbers) {
        std::cout << n << " ";
    }
    std::cout << std::endl;

    // std::find kullanımı
    auto it = std::find(numbers.begin(), numbers.end(), 8);
    if (it != numbers.end()) {
        std::cout << "8 degeri bulundu: " << *it << std::endl;
    } else {
        std::cout << "8 degeri bulunamadi." << std::endl;
    }

    // std::for_each ile lambda kullanımı (C++11)
    std::cout << "Her elemani ikiyle carp: ";
    std::for_each(numbers.begin(), numbers.end(), [](int& val) { 
        val *= 2;
        std::cout << val << " ";
    });
    std::cout << std::endl;

    return 0;
}

#include <vector>
#include <algorithm>
#include <iostream>

// Geleneksel fonksiyon nesnesi
struct KarsilastirBuyuktenKucuge {
    bool operator()(int a, int b) const {
        return a > b;
    }
};

int main() {
    std::vector<int> nums = {5, 2, 8, 1, 9, 4};

    // Fonksiyon nesnesi ile siralama
    std::sort(nums.begin(), nums.end(), KarsilastirBuyuktenKucuge());
    std::cout << "Fonksiyon nesnesiyle siralanmis: ";
    for (int n : nums) {
        std::cout << n << " ";
    }
    std::cout << std::endl;

    // Lambda ifadesi ile siralama (modern C++ tercih edilen)
    std::vector<int> nums2 = {5, 2, 8, 1, 9, 4};
    std::sort(nums2.begin(), nums2.end(), [](int a, int b) { return a < b; });
    std::cout << "Lambda ile siralanmis: ";
    for (int n : nums2) {
        std::cout << n << " ";
    }
    std::cout << std::endl;

    return 0;
}

• std::stack: Bir yığın veri yapısı (LIFO - Last-In, First-Out) sağlar.
• std::queue: Bir kuyruk veri yapısı (FIFO - First-In, First-Out) sağlar.
• std:riority_queue: En yüksek öncelikli elemanın her zaman üstte olduğu bir kuyruk sağlar.

#include <stack>
#include <iostream>

int main() {
    std::stack<int> s;
    s.push(10);
    s.push(20);
    s.push(30);

    std::cout << "Stack elemanlari (LIFO): ";
    while (!s.empty()) {
        std::cout << s.top() << " ";
        s.pop();
    }
    std::cout << std::endl;

    return 0;
}

std:stream_iterator

• Yeniden Kullanılabilirlik: Genellikle tekrar eden veri yapıları ve algoritmalar için sıfırdan kod yazma ihtiyacını ortadan kaldırır.
• Verimlilik: STL bileşenleri, çoğu kullanım durumu için son derece optimize edilmiştir ve genellikle elle yazılmış kodlardan daha verimlidir.
• Standardizasyon: Kodunuzun diğer C++ geliştiricileri tarafından daha kolay anlaşılmasını ve sürdürülmesini sağlar.
• Güvenilirlik: Kütüphane uzun yıllardır kapsamlı bir şekilde test edilmiş ve hata ayıklanmıştır, bu da daha az hata içeren kod demektir.
• Geliştirme Hızı: Hazır bileşenler sayesinde geliştirme süreçleri hızlanır.

• Doğru Konteyneri Seçmek: Uygulamanızın gereksinimlerine göre en uygun konteyneri seçmek kritik öneme sahiptir. Örneğin, sık sık eleman ekleme/silme yapıyorsanız std::list veya std::deque, rastgele erişim önceliğiniz varsa std::vector tercih edilebilir. Daha detaylı bilgi için cppreference.com adresindeki konteyner referanslarına bakabilirsiniz.
• Vector İçin `reserve()` Kullanımı: Eğer bir std::vector'a çok sayıda eleman ekleyeceğinizi biliyorsanız, önceden reserve() fonksiyonunu kullanarak bellek yeniden tahsislerini (reallocations) ve buna bağlı performans kayıplarını önleyebilirsiniz.
• Algoritmaları Tercih Edin: Kendi döngülerinizi yazmak yerine, C++'ın sunduğu zengin algoritma kütüphanesini kullanın. Bu, sadece kodunuzu kısaltmakla kalmaz, aynı zamanda genellikle daha optimize edilmiş kod kullanmanızı sağlar.
• Taşıma Semantiği (Move Semantics): C++11 ile gelen taşıma semantiği, özellikle büyük nesnelerle çalışırken performans artışı sağlayabilir. STL konteynerleri ve algoritmaları taşıma semantiğini destekler.
• Lambdalar ve Fonksiyon Nesneleri: Algoritmalarla birlikte daha esnek ve okunabilir kod yazmak için lambdaları veya fonksiyon nesnelerini kullanın.
• Referansları ve Const İfadeleri Kullanın: Konteynerlerde dolaşırken veya fonksiyonlara elemanları aktarırken gereksiz kopyalamayı önlemek için referansları ve `const` uygunluğunu kullanın.