pair dan tuple C++: mengelompokkan nilai tanpa struct

Dua nilai, satu objek

Kadang kamu perlu menyimpan dua hal bersama-sama: nama dan skor, x dan y, penanda "berhasil atau tidak" dan hasilnya. Kamu bisa mendefinisikan struct untuk setiap pasangan seperti itu, tapi untuk pengelompokan sekali pakai itu terlalu repot. std::pair (dari <utility>) menggabungkan tepat dua nilai ke dalam satu objek, dan std::tuple (dari <tuple>) memperluas ide itu ke sejumlah nilai yang tetap.

Kamu sebenarnya sudah bertemu std::pair secara tidak langsung: setiap elemen std::map adalah pair<const Key, Value>. Halaman ini membahasnya secara terang dan menunjukkan cara modern yang mudah dibaca untuk membuat dan membongkar tipe-tipe ini.

#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;
}

Kedua member-nya selalu bernama .first dan .second, dan tidak mengikuti nama variabelmu. Itulah harga dari tipe generik: nama field-nya menunjukkan posisi, bukan arti.

Membuat pair

Ada tiga cara umum untuk membuat pair, dan semuanya menghasilkan objek yang sama.

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

int main() {
    // 1. Brace initialization - the modern default
    pair<string, int> a{"Boris", 85};

    // 2. std::make_pair - the type is deduced from the arguments
    auto b = make_pair(string("Rosa"), 78);

    // 3. Assigning into an existing pair
    pair<string, int> c;
    c.first = "Liang";
    c.second = 92;

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

make_pair menebak tipe elemen untukmu, dan itu berguna sebelum C++17. Sekarang inisialisasi dengan kurung kurawal ditambah class template argument deduction (pair p{"Boris", 85};) sudah cukup untuk sebagian besar kasus, tapi kamu masih akan melihat make_pair di banyak kode yang sudah ada.

Ada satu jebakan soal deduksi tipe: make_pair("hi", 3) menghasilkan pair<const char*, int>, bukan pair<string, int>. String literal bukan std::string. Kalau kamu butuh string, tulis secara eksplisit, misalnya make_pair(string("hi"), 3), atau tulis lengkap tipe pair-nya. Kalau tidak, nanti kamu bisa mendapat hasil perbandingan atau penyalinan yang mengejutkan.

Membongkar dengan structured binding

Membaca .first dan .second di mana-mana cepat membuat kode sulit dibaca, karena namanya tidak memberi tahu apa pun. Structured binding di C++17 memungkinkan kamu memberi nama sungguhan untuk kedua field itu dalam satu baris:

#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;
}

Fitur ini sangat berguna di for berbasis range yang menelusuri map, karena setiap elemennya adalah pair. Alih-alih it->first / it->second, kamu langsung memberi nama key dan value-nya:

#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;
}

Pakai const auto& di dalam loop, sama seperti untuk elemen container lainnya. Cara ini menghindari penyalinan setiap pair dan menunjukkan bahwa kamu hanya membaca. Kalau & dihapus, setiap entri akan disalin, dan itu bug performa yang diam-diam terjadi pada map yang besar.

Kalau dua tidak cukup: tuple

pair hanya sampai dua nilai. Kalau kamu butuh tiga atau lebih, std::tuple adalah ide yang sama dengan jumlah bebas. Kamu membuatnya dengan inisialisasi kurung kurawal atau make_tuple, lalu membacanya dengan std::get<N>, dengan N berupa indeks yang diketahui saat kompilasi.

#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;
}

Indeks di dalam get<> harus konstanta yang diketahui saat kompilasi. get<i>(record) dengan i berupa variabel runtime tidak akan bisa dikompilasi. Field tuple bisa punya tipe yang berbeda-beda, jadi tipe elemennya harus ditentukan saat kompilasi, bukan saat program berjalan. Kalau kamu ternyata butuh indeks runtime, kemungkinan yang kamu perlukan adalah vector.

Structured binding juga bisa dipakai untuk tuple, dan inilah cara yang mudah dibaca untuk memakainya:

#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;
}

Mengembalikan banyak nilai

Alasan sehari-hari memakai tipe-tipe ini adalah untuk mengembalikan lebih dari satu nilai dari sebuah fungsi tanpa membuat struct baru atau repot dengan parameter output. Gabungkan hasilnya ke dalam pair atau tuple, lalu bongkar di tempat pemanggilannya.

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

// Returns (success flag, parsed value)
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;
}

Untuk tiga hasil atau lebih, kembalikan tuple dengan cara yang sama. Ada juga std::tie, trik lama yang membongkar nilai ke variabel yang sudah ada, bukan mendeklarasikan variabel baru. Ini berguna saat kamu ingin mengabaikan sebuah field dengan std::ignore:

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

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

int main() {
    int score;
    // Pull out only the score; ignore name and gpa
    tie(ignore, score, ignore) = getRecord();

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

Tapi tahu kapan berhenti: kalau kelompok field yang sama muncul di lebih dari satu tempat, atau kamu terus lupa apakah .second itu skor atau jumlah, definisikan struct dengan member yang punya nama. pair dan tuple paling cocok untuk pengelompokan lokal yang berumur pendek; field bernama lebih baik begitu datanya hidup lebih lama daripada satu ekspresi.

Membandingkan dan mengurutkan

Ada bonus yang berguna: pair dan tuple sudah punya operator perbandingan bawaan yang bekerja secara leksikografis. Mereka membandingkan elemen pertama, dan baru beralih ke elemen berikutnya kalau elemen pertamanya sama. Ini membuat mereka sempurna sebagai kunci untuk pengurutan.

#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());  // by age, then name

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

Perhatikan bahwa urutan field-nya penting: menaruh age di depan berarti data diurutkan terutama berdasarkan umur, lalu berdasarkan nama kalau umurnya sama. Kalau kamu ingin mengurutkan berdasarkan nama dulu, tukar urutan elemen tuple-nya. Perbandingan bawaan inilah yang membuat pair<priority, item> jadi pola yang umum untuk priority queue.

Berikutnya: iterator

Kamu sudah melihat .first, .second, it->first, dan *it muncul di sekitar container. Yang sebenarnya menghubungkan elemen pair dengan map tempatnya berada adalah iterator. Halaman berikutnya membahas iterator dengan tuntas: apa yang sebenarnya dikembalikan begin() dan end(), bagaimana ++it menelusuri container, dan jebakan iterator invalidation yang menyebabkan beberapa undefined behavior paling parah di C++.