C++ Standard Library'ye Genel Bakış

C++ Standard Library (STL dâhil), üretkenliği artıran, güvenli ve performanslı hazır bileşenler sunar: kapsayıcılar (containers), iteratörler, algoritmalar, dizgiler, akışlar (I/O), zaman, dosya sistemi, eşzamanlılık ve yardımcı tipler. Bu yazı, en çok kullanılan bölümleri özetleyip kısa, çalışır örneklerle yol haritası sunar.

1) Başlık (Header) Yapısı ve Temel Çağrım

STL modülerdir; ihtiyacınız olan başlığı dahil etmek performans ve derleme süresi açısından önemlidir.

• <vector>, <array>, <list>, <deque>
• <map>, <set>, <unordered_map>, <unordered_set>
• <algorithm>, <numeric>, <iterator>, <ranges> (C++20)
• <string>, <string_view>, <regex>
• <iostream>, <fstream>, <sstream>
• <chrono>, <filesystem>, <random>
• <memory> (smart pointer), <optional>, <variant>, <any>
• <thread>, , <future>, <condition_variable>

Derleme: MSVC: cl /std:c++20 main.cpp GCC/Clang: g++ -std=c++20 main.cpp -o app

2) Kapsayıcılar (Containers)

Kapsayıcılar veri tutar, iteratörlerle gezilir ve algoritmalarla işlenir.

#include <vector>
#include <unordered_map>
#include <iostream>
using namespace std;

int main() {
    vector<int> v; v.reserve(5); // kapasite ayırma (realloc azaltır)
    v.emplace_back(3); v.emplace_back(1); v.emplace_back(2);

    unordered_map<string,int> freq;
    for (int x : v) freq[to_string(x)]++;

    cout << "v size=" << v.size() << ", 2 freq=" << freq["2"] << "\n";
}

3) İteratörler ve Algoritmalar

İteratörler kapsayıcıyı soyutlar; <algorithm> çoğu işlevi kapsayıcıdan bağımsız sunar.

#include <vector>
#include <algorithm>
#include <numeric>   // accumulate
#include <iostream>
using namespace std;

int main() {
    vector<int> a{5,1,4,2,3};

    sort(a.begin(), a.end());                 // 1 2 3 4 5
    int s = accumulate(a.begin(), a.end(), 0);// toplam: 15

    auto it = find(a.begin(), a.end(), 4);    // 4 var mı?
    if (it != a.end()) *it = 40;              // 1 2 3 40 5

    // Dönüştürme: her elemana 10 ekle
    transform(a.begin(), a.end(), a.begin(),
              [](int x){ return x + 10; });

    for (int x : a) cout << x << ' ';
}

4) C++20 Ranges (Kısaca)

Ranges, algoritmaları “pipe” stiliyle birleştirmenizi sağlar. Derleyici desteği gerekebilir.

#include <vector>
#include <ranges>
#include <iostream>
using namespace std;

int main() {
    vector<int> v{1,2,3,4,5,6};
    auto even_times10 = v 
      | views::filter([](int x){ return x%2==0; })
      | views::transform([](int x){ return x*10; });

    for (int x : even_times10) cout << x << ' '; // 20 40 60
}

5) string, string_view ve regex

std::string sahipliklidir; std::string_view kopyasız görüntüdür (ömür yönetimine dikkat). <regex> basit desen eşlemede iş görür.

#include <string>
#include <string_view>
#include <regex>
#include <iostream>
using namespace std;

bool is_email(string_view s) {
    static const regex re(R"((\w+)(\.\w+)*@(\w+)(\.\w+)+)");
    return regex_match(s.begin(), s.end(), re);
}

int main() {
    string name = "Ada Lovelace";
    string_view view = name; // kopya yok
    cout << view.substr(0, 3) << "\n"; // "Ada"
    cout << boolalpha << is_email("dev@example.com") << "\n";
}

6) I/O Akışları (iostream, fstream, sstream)

Akışlar operatörlerle zincirlenir. fstream dosya okur/yazar, stringstream metin ayrıştırır.

#include <fstream>
#include <sstream>
#include <iostream>
#include <string>
using namespace std;

int main() {
    ofstream out("data.txt");
    out << "42, Modern C++\n"; out.close();

    ifstream in("data.txt");
    string line; getline(in, line);

    stringstream ss(line);
    int id; char comma; string title;
    ss >> id >> comma; getline(ss, title);
    cout << "id=" << id << " title=" << title << "\n";
}

7) Zaman ve Süre (chrono)

<chrono> ile süre ölçümü ve tarih/zaman işlemleri yapılır.

#include <chrono>
#include <iostream>
using namespace std;

int main() {
    using namespace chrono;
    auto t0 = steady_clock::now();

    // iş...
    for (volatile int i=0;i<1000000;i++) {}

    auto t1 = steady_clock::now();
    cout << "ms=" << duration_cast<milliseconds>(t1 - t0).count() << "\n";
}

8) Dosya Sistemi (filesystem)

Platform bağımsız dosya/klasör işlemleri. MSVC’de C++17, GCC’de -lstdc++fs gereksinimi eski sürümlerde vardı; modern derleyicilerde gerekmez.

#include <filesystem>
#include <iostream>
using namespace std;
namespace fs = std::filesystem;

int main() {
    for (const auto& e : fs::directory_iterator(".")) {
        cout << e.path().filename().string() << "\n";
    }
}

9) Rastgele Sayılar (random)

Modern C++’ta Mersenne Twister (mt19937) ve dağılımlar kullanılır.

#include <random>
#include <iostream>
using namespace std;

int main() {
    random_device rd;
    mt19937 gen(rd());
    uniform_int_distribution<int> dist(1, 6);

    for (int i=0;i<5;i++) cout << dist(gen) << ' ';
}

10) Bellek ve Yardımcı Tipler

<memory> smart pointer’lar: unique_ptr, shared_ptr, weak_ptr. <optional> değer var/yok, <variant> tip güvenli birlik, <any> tip-erasure sağlar.

#include <memory>
#include <optional>
#include <variant>
#include <iostream>
using namespace std;

optional<int> parse_pos_int(int x) { return x>=0 ? optional<int>(x) : nullopt; }

int main() {
    auto p = make_unique<int>(42);
    cout << *p << "\n";

    if (auto v = parse_pos_int(-7)) cout << *v; else cout << "yok\n";

    variant<int,string> v2 = 10; v2 = string("metin");
    visit([](auto& t){ cout << t << "\n"; }, v2);
}

11) Eşzamanlılık (thread, mutex, future)

Temel çok iş parçacığı nesneleri ve eşitleme ilkelidir. Basit bir örnek:

#include <thread>
#include <mutex>
#include <future>
#include <iostream>
using namespace std;

mutex m; int counter = 0;

void work(int n){
    lock_guard<mutex> lk(m);
    counter += n;
}

int main() {
    thread t1(work, 1), t2(work, 2);
    t1.join(); t2.join();

    auto fut = async(launch::async, []{ return 40 + 2; });
    cout << "counter=" << counter << " answer=" << fut.get() << "\n";
}

12) Sayısal Araçlar (numeric, cmath)

<numeric> toplama/katlama, <cmath> matematik fonksiyonları sunar.

#include <vector>
#include <numeric>
#include <iostream>
using namespace std;

int main() {
    vector<double> x{1.0, 2.0, 3.0};
    double avg = accumulate(x.begin(), x.end(), 0.0) / x.size();
    cout << "ortalama=" << avg << "\n";
}

13) Hızlı Seçimler (Ne Zaman Hangisi?)

• Genel amaç kapsayıcı: vector
• Sıralı anahtar-değer ve aralık arama: map/set
• En hızlı anahtar erişimi (karma tablosu): unordered_map/unordered_set
• Akış işleme ve “pipeline”: ranges (C++20)
• Dosya/klasör: filesystem
• Yüksek çözünürlüklü zaman ve süre: chrono
• Güvenli dönüş (var/yok): optional; çoklu tip: variant

14) TL;DR

İlişkili Makaleler