std::pair în C++

#include <utility>

std::pair<T1, T2> p{valoare1, valoare2};
auto p = std::make_pair(valoare1, valoare2);

Ce face std::pair

std::pair ține exact două valori: first și second. Este folosit peste tot în biblioteca standard: elementele unui std::map sunt perechi cheie-valoare, iar insert returnează o pereche (iterator, bool). Este și un mod simplu de a returna două valori dintr-o funcție.

std::make_pair(a, b) creează o pereche și deduce singur tipurile. Din C++17, același lucru îl face std::pair{a, b}. Cu auto [x, y] = pereche; (structured bindings) despachetezi perechea în două variabile.

Perechile se pot compara: întâi după first, iar la egalitate după second. De aceea un vector de perechi se sortează direct cu std::sort. În C++23, std::println le afișează sub forma (a, b).

Parametri

Parametru	Descriere
T1, T2	Tipurile celor două valori.
valoare1, valoare2	Valorile pentru first și second.

Ce returnează

std::make_pair returnează un std::pair cu tipurile deduse din argumente.

Exemple

Exemplul 1: Creare și acces

#include <print>
#include <string>
#include <utility>

int main() {
    std::pair<std::string, int> elev{"Ana", 10};
    auto oras = std::make_pair("Iași", 271692);     // pair<const char*, int>
    std::pair punct{3.5, -2.0};                     // C++17: pair<double, double>

    std::println("{} are nota {}", elev.first, elev.second);
    std::println("{}: {} locuitori", oras.first, oras.second);
    std::println("punct: {}", punct);

    auto [nume, nota] = elev;                       // despachetare
    std::println("{} / {}", nume, nota);
}

Rezultat

Ana are nota 10
Iași: 271692 locuitori
punct: (3.5, -2)
Ana / 10

Exemplul 2: Două valori returnate dintr-o funcție

#include <print>
#include <utility>
#include <vector>

std::pair<int, int> min_max(const std::vector<int>& v) {
    int mic = v.front();
    int mare = v.front();
    for (int x : v) {
        if (x < mic) mic = x;
        if (x > mare) mare = x;
    }
    return {mic, mare};
}

int main() {
    auto [mic, mare] = min_max({14, 3, 27, 9});
    std::println("Minim {}, maxim {}", mic, mare);
}

Rezultat

Minim 3, maxim 27

Exemplul 3: Sortarea unui vector de perechi

Perechile se compară după first, apoi după second: la puncte egale, ordinea este alfabetică.

#include <algorithm>
#include <print>
#include <string>
#include <utility>
#include <vector>

int main() {
    std::vector<std::pair<int, std::string>> clasament{{80, "Ion"}, {95, "Ana"}, {80, "Dan"}, {70, "Eva"}};
    std::sort(clasament.begin(), clasament.end());
    std::println("{}", clasament);
}

Rezultat

[(70, "Eva"), (80, "Dan"), (80, "Ion"), (95, "Ana")]

Greșeli frecvente

• Folosești std::make_pair("text", 1) și te aștepți la un std::string. Tipul dedus este const char*; scrie explicit std::pair<std::string, int> dacă ai nevoie de un string.
• Folosești perechi imbricate (p.second.first) pentru date cu mai multe câmpuri. Codul devine greu de citit; definește o struct cu nume clare.

Comenzi înrudite

• std::tuple: Grupează oricâte valori de tipuri diferite într-un singur obiect; generalizarea lui std::pair.
• std::get: Citește elementul unui tuplu, al unei perechi sau al unui std::array după poziție (sau după tip), la compilare.
• std::tie: Creează un tuplu de referințe la variabile existente: despachetează un tuplu în ele sau compară mai multe câmpuri deodată.
• std::map: Dicționar ordonat: asociază fiecărei chei unice o valoare și păstrează cheile sortate.