C++ pair ve tuple: struct kullanmadan değerleri gruplama

İki değer, tek nesne

Bazen iki şeyi bir arada tutman gerekir: bir ad ve bir puan, bir x ve bir y, bir "işe yaradı mı?" bayrağı ve sonuç. Böyle her gruplama için bir struct tanımlayabilirsin, ama tek kullanımlık gruplamalar için bu çok fazla tören demek. std::pair (<utility> başlığından) tam olarak iki değeri tek bir nesnede birleştirir, std::tuple (<tuple> başlığından) ise bunu sabit sayıdaki herhangi bir değere genelleştirir.

Buraya gelene kadar std::pair ile dolaylı olarak zaten karşılaştın: bir std::map'in her elemanı bir pair<const Key, Value>'dır. Bu sayfa bunu açıkça ortaya koyar ve bu türleri oluşturmanın ve açmanın modern, okunaklı yollarını gösterir.

#include <iostream>
#include <utility>   // std::pair
#include <string>
using namespace std;

int main() {
    pair<string, int> player{"Ada", 90};

    cout << player.first << " scored " << player.second << "\n";
    return 0;
}

İki üye her zaman .first ve .second olarak adlandırılır; senin değişkenlerinin adlarını almazlar. Genel bir türün bedeli budur: alan adları açıklayıcı değil, konumsaldır.

Pair oluşturma

Bir pair oluşturmanın üç yaygın yolu vardır ve hepsi aynı nesneyi üretir.

#include <iostream>
#include <utility>
#include <string>
using namespace std;

int main() {
    // 1. Süslü parantezle başlatma - modern varsayılan
    pair<string, int> a{"Boris", 85};

    // 2. std::make_pair - tür argümanlardan çıkarsanır
    auto b = make_pair(string("Rosa"), 78);

    // 3. Var olan bir pair'e atama
    pair<string, int> c;
    c.first = "Liang";
    c.second = 92;

    cout << a.first << " " << b.first << " " << c.first << "\n";
    return 0;
}

make_pair eleman türlerini senin yerine çıkarsar; bu, C++17'den önce işe yarayan bir özellikti. Bugün süslü parantezle başlatma artı sınıf şablonu argüman çıkarımı (pair p{"Boris", 85};) çoğu durumu kapsar, ama mevcut kodda hâlâ her yerde make_pair göreceksin.

Çıkarımla ilgili bir tuzak: make_pair("hi", 3), pair<string, int> değil pair<const char*, int> çıkarsar. Dize literalleri std::string değildir. Bir string'e ihtiyacın varsa bunu açıkça belirt —make_pair(string("hi"), 3) ya da pair türünü tam olarak yaz— aksi takdirde ilerleyen aşamalarda şaşırtıcı karşılaştırmalar veya kopyalar elde edebilirsin.

Structured bindings ile açma

Her yerde .first ve .second okumak hızla okunaksız hale gelir, çünkü adlar sana hiçbir şey söylemez. C++17 structured bindings, iki alana tek satırda gerçek adlar vermeni sağlar:

#include <iostream>
#include <utility>
#include <string>
using namespace std;

int main() {
    pair<string, int> player{"Ada", 90};

    auto [name, score] = player;   // name = "Ada", score = 90

    cout << name << " scored " << score << "\n";
    return 0;
}

Bu, her elemanın bir pair olduğu bir map üzerinde aralık tabanlı bir for içinde gerçekten parlar. it->first / it->second yerine, anahtarı ve değeri doğrudan adlandırırsın:

#include <iostream>
#include <map>
#include <string>
using namespace std;

int main() {
    map<string, int> scores = {{"Ada", 90}, {"Boris", 85}, {"Rosa", 78}};

    for (const auto& [name, score] : scores) {
        cout << name << ": " << score << "\n";
    }
    return 0;
}

Döngüde, herhangi bir kapsayıcı elemanında yapacağın gibi const auto& kullan; bu her pair'i kopyalamaktan kaçınır ve yalnızca okuduğunu belirtir. &'yi kaldırırsan her girdiyi kopyalarsın; bu, büyük bir map üzerinde sessiz bir performans hatasıdır.

İki yeterli olmadığında: tuple

Bir pair iki değerde durur. Üç veya daha fazlasına ihtiyacın olduğunda, std::tuple aynı fikrin keyfi sayıda olanıdır. Onu süslü parantezle başlatma veya make_tuple ile oluşturur, N'nin derleme zamanında bilinen bir indeks olduğu std::get<N> ile okursun.

#include <iostream>
#include <tuple>
#include <string>
using namespace std;

int main() {
    tuple<string, int, double> record{"Ada", 90, 4.0};

    cout << get<0>(record) << " "    // Ada
         << get<1>(record) << " "    // 90
         << get<2>(record) << "\n";  // 4

    auto deduced = make_tuple("Boris", 85, 3.7);  // tuple<const char*, int, double>
    cout << get<1>(deduced) << "\n";
    return 0;
}

get<> içindeki indeks, derleme zamanında bilinen bir sabit olmalıdır. i'nin bir çalışma zamanı değişkeni olduğu get<i>(record) derlenmez: bir tuple'ın alanları farklı türlerde olabilir, dolayısıyla eleman türünün çalışma zamanında değil, derleme sırasında çözülmesi gerekir. Kendini çalışma zamanı indeksi isterken bulursan, muhtemelen istediğin şey bir vector'dür.

Structured bindings tuple'larda da çalışır ve bir tuple'ı tüketmenin okunaklı yolu budur:

#include <iostream>
#include <tuple>
#include <string>
using namespace std;

int main() {
    tuple<string, int, double> record{"Ada", 90, 4.0};

    auto [name, score, gpa] = record;

    cout << name << " - score " << score << ", gpa " << gpa << "\n";
    return 0;
}

Birden çok değer döndürme

Bu türlere başvurmanın günlük nedeni, bir struct uydurmadan veya çıkış parametreleriyle uğraşmadan bir fonksiyondan birden fazla değer döndürmektir. Sonuçları bir pair veya tuple içinde topla ve çağrı yerinde aç.

#include <iostream>
#include <utility>
#include <string>
using namespace std;

// (başarı bayrağı, ayrıştırılmış değer) döndürür
pair<bool, int> parsePositive(const string& text) {
    int value = stoi(text);
    if (value <= 0) return {false, 0};
    return {true, value};
}

int main() {
    auto [ok, value] = parsePositive("42");

    if (ok) cout << "Got " << value << "\n";
    else    cout << "Not a positive number\n";
    return 0;
}

Üç veya daha fazla sonuç için aynı şekilde bir tuple döndür. Ayrıca std::tie da vardır; bu, yeni değişkenler bildirmek yerine var olan değişkenlere açan daha eski bir tekniktir ve bir alanı std::ignore ile yok saymak istediğinde kullanışlıdır:

#include <iostream>
#include <tuple>
#include <string>
using namespace std;

tuple<string, int, double> getRecord() {
    return {"Ada", 90, 4.0};
}

int main() {
    int score;
    // Yalnızca puanı al; name ve gpa'yı yok say
    tie(ignore, score, ignore) = getRecord();

    cout << "score = " << score << "\n";
    return 0;
}

Ne zaman durman gerektiğine gelince: aynı alan grubu birden fazla yerde ortaya çıkıyorsa veya .second'ın puan mı yoksa sayım mı olduğunu sürekli unutuyorsan, adlandırılmış üyelere sahip bir struct tanımla. pair ve tuple, yerel ve kısa ömürlü gruplamalar için en iyisidir; veri tek bir ifadeden daha uzun yaşadığı anda adlandırılmış alanlar kazanır.

Karşılaştırma ve sıralama

Kullanışlı bir bonus: pair ve tuple, sözlükbilimsel (lexicographic) olarak çalışan yerleşik karşılaştırma operatörleriyle gelir; ilk elemanı karşılaştırır ve yalnızca ilkler eşit olduğunda bir sonrakine geçerler. Bu da onları mükemmel sıralama anahtarları yapar.

#include <iostream>
#include <vector>
#include <utility>
#include <string>
#include <algorithm>
using namespace std;

int main() {
    vector<pair<int, string>> people = {
        {30, "Ada"}, {25, "Boris"}, {30, "Rosa"}
    };

    sort(people.begin(), people.end());  // önce yaşa, sonra ada göre

    for (const auto& [age, name] : people) {
        cout << age << " " << name << "\n";
    }
    // 25 Boris / 30 Ada / 30 Rosa
    return 0;
}

Alanların sırasının önemli olduğuna dikkat et: age'i öne koymak önce yaşa, eşitlik bozucu olarak sonra ada göre sıralar. Önce ada göre bir sıralama isteseydin, tuple'ın eleman sırasını değiştirirdin. Bu varsayılan karşılaştırma, pair<priority, item>'in öncelik kuyrukları için neden yaygın bir kalıp olduğunun tam olarak nedenidir.

Sıradaki: Yineleyiciler (Iterators)

Artık kapsayıcıların etrafında .first, .second, it->first ve *it'in ortaya çıktığını gördün; bir pair elemanını içinde yaşadığı map'e gerçekten bağlayan şey bir yineleyici (iterator)'dir. Bir sonraki sayfa yineleyicileri gerektiği gibi açıklar: begin() ve end()'in gerçekte ne döndürdüğü, ++it'in bir kapsayıcıyı nasıl dolaştığı ve C++'taki en çirkin tanımsız davranışlardan bazılarına neden olan yineleyici geçersizleştirme tuzakları.