C++ pair and tuple: Group Values Without a Struct

Two Values, One Object

Sometimes you need to keep two things together - a name and a score, an x and a y, a "did it work" flag and the result. You could define a struct for every such pairing, but for throwaway groupings that is a lot of ceremony. std::pair (from <utility>) bundles exactly two values into one object, and std::tuple (from <tuple>) generalizes that to any fixed number of values.

You already met std::pair indirectly on the way here: every element of a std::map is a pair<const Key, Value>. This page makes that explicit and shows the modern, readable ways to build and unpack these types.

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

The two members are always called .first and .second - they don't take the names of your variables. That's the price of a generic type: the field names are positional, not descriptive.

Making Pairs

There are three common ways to create a pair, and they all produce the same object.

#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 deduces the element types for you, which was handy before C++17. Today brace init plus class-template argument deduction (pair p{"Boris", 85};) covers most cases, but you'll still see make_pair everywhere in existing code.

One gotcha with deduction: make_pair("hi", 3) deduces pair<const char*, int>, not pair<string, int>. String literals are not std::string. If you need a string, say so explicitly - make_pair(string("hi"), 3) or spell out the pair type - otherwise you may get surprising comparisons or copies later.

Unpacking With Structured Bindings

Reading .first and .second everywhere gets unreadable fast, because the names tell you nothing. C++17 structured bindings let you give the two fields real names in one line:

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

This shines in a range-based for over a map, where each element is a pair. Instead of it->first / it->second, you name the key and value directly:

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

Use const auto& in the loop, just as you would for any container element - it avoids copying each pair and signals you're only reading. Drop the & and you copy every entry; that's a quiet performance bug on a large map.

When Two Isn't Enough: tuple

A pair stops at two values. When you need three or more, std::tuple is the same idea with an arbitrary count. You build one with brace init or make_tuple, and you read it with std::get<N>, where N is a compile-time index.

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

The index inside get<> must be a constant known at compile time. get<i>(record) where i is a runtime variable will not compile - a tuple's fields can have different types, so the element type has to be resolved during compilation, not at run time. If you find yourself wanting a runtime index, you probably want a vector instead.

Structured bindings work on tuples too, and this is the readable way to consume one:

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

Returning Multiple Values

The everyday reason to reach for these types is returning more than one value from a function without inventing a struct or juggling output parameters. Bundle the results into a pair or tuple and unpack at the call site.

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

For three or more results, return a tuple the same way. There's also std::tie, an older trick that unpacks into existing variables rather than declaring new ones - useful when you want to ignore a field with 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;
}

When to stop, though: if the same group of fields shows up in more than one place, or you keep forgetting whether .second is the score or the count, define a struct with named members. pair and tuple are best for local, short-lived groupings; named fields win the moment the data lives longer than a single expression.

Comparing and Sorting

A handy bonus: pair and tuple come with built-in comparison operators that work lexicographically - they compare the first element, and only fall back to the next when the firsts are equal. That makes them perfect keys for sorting.

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

Notice the order of the fields matters: putting age first sorts by age primarily, then by name as a tiebreaker. If you wanted name-first ordering, you'd swap the tuple's element order. This default comparison is exactly why pair<priority, item> is a common idiom for priority queues.

Next: Iterators

You've now seen .first, .second, it->first, and *it show up around containers - the thing that actually connects a pair element to the map it lives in is an iterator. The next page unpacks iterators properly: what begin() and end() really return, how ++it walks a container, and the iterator-invalidation traps that cause some of the nastiest undefined behavior in C++.