STL Genel Bakış ve Felsefesi

Coddy'nin C++ Journey'sinin Nesne Yönelimli Programlama bölümünün bir parçası — ders 70 / 104.

Standart Şablon Kütüphanesi (STL), yaygın veri yapılarını ve algoritmaları sağlayan şablon tabanlı sınıflar ve fonksiyonlardan oluşan bir koleksiyondur. Öğrendiğiniz şablon kavramları üzerine inşa edilen STL, güçlü bir tasarım felsefesini somutlaştırır: veri depolamayı veri işlemeden ayırmak.

STL, birlikte çalışan üç temel bileşen etrafında organize edilmiştir:

Bileşen	Amaç	Örnekler
Kapsayıcılar	Nesne koleksiyonlarını depolar	`vector`, `map`, `set`
Yineleyiciler	Kapsayıcı öğelerine erişim sağlar	Giriş, çıkış, rastgele erişim
Algoritmalar	Veriler üzerinde işlemler gerçekleştirir	`sort`, `find`, `transform`

Temel içgörü, algoritmaların konteynerleri doğrudan tanımamasıdır; iteratörler (iterators) aracılığıyla çalışırlar. Bu, tek bir sort algoritmasının vektörler, diziler ve doğru iteratör tipini sağlayan herhangi bir konteyner ile çalıştığı anlamına gelir:

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

int main() {
    std::vector<int> nums = {5, 2, 8, 1, 9};
    
    std::sort(nums.begin(), nums.end());
    
    for (int n : nums) {
        std::cout << n << " ";
    }
    // Çıktı: 1 2 5 8 9
}

Bu ayrım, karıştırıp eşleştirebileceğiniz anlamına gelir - yeni kod yazmadan herhangi bir algoritmayı herhangi bir uyumlu konteyner ile kullanabilirsiniz. STL, yaygın veri yapılarını yeniden icat etmek yerine problemlere odaklanabilmeniz için savaşta test edilmiş, optimize edilmiş uygulamalar sunar.

Görev

Kolay

Kapsayıcıları (containers), yineleyicileri (iterators) ve algoritmaları birbirinden ayırma şeklindeki STL felsefesini gösteren basit bir veri işleme sistemi kuralım. STL bileşenleriyle çalışan bir yardımcı modül ve bu parçaların nasıl bir araya geldiğini gösteren bir ana program oluşturacaksınız.

İki dosya oluşturacaksınız:

DataProcessor.h: STL'nin tasarım felsefesini gösteren, yineleyiciler aracılığıyla STL kapsayıcılarıyla çalışan yardımcı fonksiyonları tanımlayın.
Bir std::vector<int>& alan ve tüm öğeleri aralarında boşluk bırakarak yazdıran, ardından bir alt satıra geçen printVector adında bir fonksiyon oluşturun. Kapsayıcıyı dolaşmak için yineleyicileri (begin() ve end()) kullanın.

Bir std::vector<int>& alan, bunu std::sort kullanarak sıralayan, ardından sıralanmış öğeleri aralarında boşluk bırakarak yazdıran ve bir alt satıra geçen sortAndPrint adında bir fonksiyon oluşturun.

Bir std::vector<int>& ve aranacak bir int değeri alan findElement adında bir fonksiyon oluşturun. Öğeyi bulmak için std::find kullanın. Eğer bulunursa, Found: <value> yazdırın. Bulunamazsa, Not found: <value> yazdırın.

Bir std::vector<int>& alan ve tüm öğelerin toplamını döndüren getSum adında bir fonksiyon oluşturun. Bunun için yineleyicilerle basit bir döngü kullanabilirsiniz.
main.cpp: Girişleri okuyun ve STL bileşenlerinin birlikte nasıl çalıştığını gösterin.
Beş giriş okuyun (her biri ayrı bir satırda):
1. Birinci tam sayı
2. İkinci tam sayı
3. Üçüncü tam sayı
4. Dördüncü tam sayı
5. Aranacak bir değer
Bir std::vector<int> oluşturun ve ilk dört tam sayıyı buna ekleyin. Ardından şu adımlarla STL felsefesini gösterin:
1. Original: yazdırın ve ardından printVector fonksiyonunu çağırın
2. Sorted: yazdırın ve ardından sortAndPrint fonksiyonunu çağırın
3. Arama değeriyle findElement fonksiyonunu çağırın
4. getSum kullanarak Sum: <result> yazdırın

Örneğin, 5, 2, 8, 1 ve 8 girişleri için:

Original: 5 2 8 1 
Sorted: 1 2 5 8 
Found: 8
Sum: 16

10, 30, 20, 40 ve 15 girişleri için:

Original: 10 30 20 40 
Sorted: 10 20 30 40 
Not found: 15
Sum: 100

Fonksiyonlarınızın vektörle yineleyiciler aracılığıyla nasıl çalıştığına ve std::sort ile std::find fonksiyonlarının doğru yineleyici türünü sağlayan herhangi bir kapsayıcı üzerinde nasıl işlem yaptığına dikkat edin. STL'nin tasarımının gücü budur — algoritmalar kapsayıcılardan ayrılmıştır ve birbirlerine yalnızca yineleyiciler aracılığıyla bağlanırlar.

Kopya kağıdı

Standart Şablon Kütüphanesi (STL), yaygın veri yapılarını ve algoritmaları sağlayan şablon tabanlı sınıflar ve fonksiyonlar koleksiyonudur. Veri depolamayı veri işlemeden ayırır.

STL'nin üç temel bileşeni vardır:

Bileşen	Amaç	Örnekler
Konteynerler	Nesne koleksiyonlarını depolar	`vector`, `map`, `set`
İteratörler	Konteyner öğelerine erişim sağlar	Giriş, çıkış, rastgele erişim
Algoritmalar	Veriler üzerinde işlemler gerçekleştirir	`sort`, `find`, `transform`

Algoritmalar doğrudan konteynerlerle değil, iteratörler aracılığıyla çalışır. Bu, tek bir algoritmanın uyumlu herhangi bir konteynerle çalışmasına olanak tanır:

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

int main() {
    std::vector<int> nums = {5, 2, 8, 1, 9};
    
    // İteratörleri kullanarak sırala
    std::sort(nums.begin(), nums.end());
    
    // İteratörleri kullanarak dolaş
    for (int n : nums) {
        std::cout << n << " ";
    }
    // Çıktı: 1 2 5 8 9
}

Yaygın iteratör metotları:

begin() - ilk öğeye bir iteratör döndürür
end() - son öğeden sonraki konuma bir iteratör döndürür

Yaygın STL algoritmaları:

std::sort(begin, end) - aralıktaki öğeleri sıralar
std::find(begin, end, value) - aralıkta değer arar

Kendin dene

#include <iostream>
#include <vector>
#include "DataProcessor.h"

using namespace std;

int main() {
    // Girdiden beş tam sayı oku
    int num1, num2, num3, num4, searchValue;
    cin >> num1;
    cin >> num2;
    cin >> num3;
    cin >> num4;
    cin >> searchValue;
    
    // TODO: Bir vector oluştur ve ilk dört tam sayıyı ona ekle
    
    // TODO: "Original: " yazdır ve printVector fonksiyonunu çağır
    
    // TODO: "Sorted: " yazdır ve sortAndPrint fonksiyonunu çağır
    
    // TODO: Arama değeri ile findElement fonksiyonunu çağır
    
    // TODO: "Sum: " yazdır ve ardından getSum sonucunu ekle
    
    return 0;
}