pair i tuple w C++: grupowanie wartości bez struktury

Dwie wartości, jeden obiekt

Czasem trzeba trzymać razem dwie rzeczy: imię i wynik, x i y, flagę „czy się udało” i rezultat. Można by definiować struct dla każdej takiej pary, ale przy grupowaniach jednorazowych to sporo ceremonii. std::pair (z <utility>) łączy dokładnie dwie wartości w jeden obiekt, a std::tuple (z <tuple>) uogólnia to na dowolną stałą liczbę wartości.

Z std::pair masz już pośrednio do czynienia: każdy element std::map to pair<const Key, Value>. Ta strona pokazuje to wprost i przedstawia nowoczesne, czytelne sposoby budowania i rozpakowywania tych typów.

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

Dwa pola zawsze nazywają się .first i .second: nie przejmują nazw twoich zmiennych. To cena typu generycznego: nazwy pól mówią o pozycji, a nie o znaczeniu.

Tworzenie par

Są trzy popularne sposoby tworzenia pair i wszystkie dają ten sam obiekt.

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

int main() {
    // 1. Inicjalizacja klamrowa: nowoczesny domyślny wybór
    pair<string, int> a{"Boris", 85};

    // 2. std::make_pair: typ jest dedukowany z argumentów
    auto b = make_pair(string("Rosa"), 78);

    // 3. Przypisanie do istniejącej pary
    pair<string, int> c;
    c.first = "Liang";
    c.second = 92;

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

make_pair dedukuje za ciebie typy elementów, co było wygodne przed C++17. Dziś inicjalizacja klamrowa z dedukcją argumentów szablonu klasy (pair p{"Boris", 85};) pokrywa większość przypadków, ale make_pair nadal zobaczysz wszędzie w istniejącym kodzie.

Jedna pułapka dedukcji: make_pair("hi", 3) dedukuje pair<const char*, int>, a nie pair<string, int>. Literały tekstowe to nie std::string. Jeśli potrzebujesz string, powiedz to jawnie, czyli make_pair(string("hi"), 3) albo pełny typ pary, bo inaczej później możesz trafić na zaskakujące porównania albo kopie.

Rozpakowywanie przez structured bindings

Czytanie wszędzie .first i .second szybko staje się nieczytelne, bo te nazwy nic nie mówią. Structured bindings z C++17 pozwalają w jednej linii nadać obu polom prawdziwe nazwy:

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

To błyszczy w pętli for po zakresie po map, gdzie każdy element jest pair. Zamiast it->first / it->second nazywasz klucz i wartość bezpośrednio:

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

W pętli używaj const auto&, tak jak dla każdego elementu kontenera: unikasz kopiowania każdej pair i sygnalizujesz, że tylko czytasz. Pomiń &, a skopiujesz każdy wpis; przy dużej mapie to cichy błąd wydajności.

Gdy dwie to za mało: tuple

pair kończy się na dwóch wartościach. Gdy potrzebujesz trzech lub więcej, std::tuple to ta sama idea z dowolną liczbą elementów. Tworzysz ją przez inicjalizację klamrową albo make_tuple, a odczytujesz przez std::get<N>, gdzie N to indeks znany w czasie kompilacji.

#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 w get<> musi być stałą znaną w czasie kompilacji. get<i>(record), gdzie i jest zmienną, się nie skompiluje: pola krotki mogą mieć różne typy, więc typ elementu musi zostać ustalony podczas kompilacji, a nie w czasie działania programu. Jeśli chcesz indeksu znanego dopiero w czasie wykonania, prawdopodobnie potrzebujesz vector.

Structured bindings działają też na krotkach i to jest czytelny sposób ich użycia:

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

Zwracanie wielu wartości

Codzienny powód, by sięgać po te typy, to zwracanie więcej niż jednej wartości z funkcji bez wymyślania struktury czy żonglowania parametrami wyjściowymi. Spakuj wyniki w pair albo tuple i rozpakuj je w miejscu wywołania.

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

// Zwraca (flagę powodzenia, sparsowaną wartość)
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;
}

Przy trzech lub więcej wynikach zwróć tuple w ten sam sposób. Jest też std::tie, starsza sztuczka, która rozpakowuje do istniejących zmiennych zamiast deklarować nowe; przydaje się, gdy chcesz pominąć pole przez 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;
    // Wyciągnij tylko wynik; pomiń name i gpa
    tie(ignore, score, ignore) = getRecord();

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

Kiedy jednak przestać: jeśli ta sama grupa pól pojawia się w więcej niż jednym miejscu albo ciągle zapominasz, czy .second to wynik, czy licznik, zdefiniuj struct z nazwanymi polami. pair i tuple najlepiej sprawdzają się przy lokalnych, krótko żyjących grupowaniach; nazwane pola wygrywają, gdy tylko dane żyją dłużej niż jedno wyrażenie.

Porównywanie i sortowanie

Przydatny bonus: pair i tuple mają wbudowane operatory porównania, które działają leksykograficznie: porównują pierwszy element i dopiero przy równości przechodzą do następnego. To czyni je idealnymi kluczami do sortowania.

#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());  // według wieku, potem imienia

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

Zauważ, że kolejność pól ma znaczenie: umieszczenie age jako pierwszego sortuje przede wszystkim po wieku, a imię rozstrzyga remisy. Gdyby sortowanie miało iść najpierw po imieniu, trzeba by zamienić kolejność elementów krotki. To domyślne porównanie jest właśnie powodem, dla którego pair<priority, item> to popularny idiom przy kolejkach priorytetowych.

Dalej: iteratory

Przy kontenerach pojawiają się już .first, .second, it->first i *it: to, co faktycznie łączy element pair z map, w której mieszka, to iterator. Następna strona porządnie omawia iteratory: co naprawdę zwracają begin() i end(), jak ++it przechodzi po kontenerze i jakie pułapki unieważnienia iteratorów powodują jedne z najpaskudniejszych przypadków niezdefiniowanego zachowania w C++.