C++ pair와 tuple: 구조체 없이 값 묶기

두 값, 하나의 객체

때로는 두 가지를 함께 묶어 두어야 할 때가 있습니다. 이름과 점수, x와 y, "성공했는가" 플래그와 결과처럼요. 그런 묶음마다 struct를 정의할 수도 있지만, 일회성 묶음에는 너무 번거롭습니다. std::pair(<utility> 소속)는 정확히 두 값을 하나의 객체로 묶고, std::tuple(<tuple> 소속)은 이를 고정된 임의 개수의 값으로 일반화합니다.

여기까지 오는 길에 이미 std::pair를 간접적으로 만났습니다. std::map의 각 요소는 pair<const Key, Value>입니다. 이 페이지에서는 그것을 명시적으로 다루고, 이 타입들을 만들고 풀어내는 현대적이고 읽기 좋은 방법을 보여줍니다.

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

두 멤버는 언제나 .first와 .second라고 불립니다. 여러분이 정한 변수 이름을 따라가지 않습니다. 이것이 제네릭 타입의 대가입니다. 필드 이름은 설명적이지 않고 위치 기반입니다.

pair 만들기

pair를 만드는 흔한 방법은 세 가지이며, 모두 같은 객체를 만들어 냅니다.

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

int main() {
    // 1. 중괄호 초기화 - 현대적인 기본 방식
    pair<string, int> a{"Boris", 85};

    // 2. std::make_pair - 인자로부터 타입이 추론됨
    auto b = make_pair(string("Rosa"), 78);

    // 3. 이미 존재하는 pair에 대입
    pair<string, int> c;
    c.first = "Liang";
    c.second = 92;

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

make_pair는 요소 타입을 대신 추론해 주며, C++17 이전에는 유용했습니다. 오늘날에는 중괄호 초기화에 클래스 템플릿 인자 추론(pair p{"Boris", 85};)을 더하면 대부분의 경우를 처리할 수 있지만, 기존 코드에서는 여전히 make_pair를 곳곳에서 보게 됩니다.

추론과 관련한 한 가지 함정: make_pair("hi", 3)은 pair<string, int>가 아니라 pair<const char*, int>를 추론합니다. 문자열 리터럴은 std::string이 아닙니다. string이 필요하다면 명시적으로 밝히세요. make_pair(string("hi"), 3)처럼 쓰거나 pair 타입을 그대로 적습니다. 그러지 않으면 나중에 예상치 못한 비교나 복사가 생길 수 있습니다.

구조적 바인딩으로 풀어내기

곳곳에서 .first와 .second를 읽는 것은 금세 읽기 어려워집니다. 이름이 아무것도 알려 주지 않기 때문이죠. C++17의 구조적 바인딩을 사용하면 두 필드에 한 줄로 진짜 이름을 붙일 수 있습니다.

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

이는 각 요소가 pair인 map을 범위 기반 for로 순회할 때 빛을 발합니다. it->first / it->second 대신 키와 값에 직접 이름을 붙입니다.

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

다른 컨테이너 요소와 마찬가지로 루프에서는 const auto&를 사용하세요. 각 pair의 복사를 피하고 읽기만 한다는 것을 알려 줍니다. &를 빼면 모든 항목을 복사하게 되며, 큰 map에서는 조용한 성능 버그가 됩니다.

둘로는 부족할 때: tuple

pair는 두 값에서 멈춥니다. 셋 이상이 필요할 때, std::tuple은 같은 발상을 임의의 개수로 확장한 것입니다. 중괄호 초기화나 make_tuple로 만들고, N이 컴파일 타임에 정해지는 인덱스인 std::get<N>으로 읽습니다.

#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가 런타임 변수인 get<i>(record)는 컴파일되지 않습니다. tuple의 필드는 서로 다른 타입을 가질 수 있어서, 요소 타입이 런타임이 아니라 컴파일 중에 결정되어야 하기 때문입니다. 런타임 인덱스를 원하게 된다면, 필요한 것은 아마 vector일 것입니다.

구조적 바인딩은 tuple에도 동작하며, 이것이 tuple을 다루는 읽기 좋은 방법입니다.

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

여러 값 반환하기

이 타입들에 손을 뻗는 일상적인 이유는, 구조체를 따로 만들거나 출력 매개변수를 다루지 않고도 함수에서 둘 이상의 값을 반환하기 위함입니다. 결과를 pair나 tuple로 묶고 호출 지점에서 풀어냅니다.

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

// (성공 플래그, 파싱한 값) 반환
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;
}

세 개 이상의 결과는 같은 방식으로 tuple을 반환하면 됩니다. std::tie도 있습니다. 이는 새 변수를 선언하는 대신 이미 존재하는 변수에 풀어내는 오래된 기법으로, 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;
    // score만 꺼냄; name과 gpa는 무시
    tie(ignore, score, ignore) = getRecord();

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

다만 멈춰야 할 때도 있습니다. 같은 필드 묶음이 여러 곳에 나타나거나, .second가 점수인지 개수인지 자꾸 헷갈린다면, 이름 있는 멤버를 가진 struct를 정의하세요. pair와 tuple은 지역적이고 수명이 짧은 묶음에 가장 적합합니다. 데이터가 하나의 표현식보다 오래 살아남는 순간, 이름 있는 필드가 승리합니다.

비교와 정렬

유용한 보너스: pair와 tuple에는 _사전식(lexicographic)_으로 동작하는 비교 연산자가 내장되어 있습니다. 첫 번째 요소를 비교하고, 첫 요소가 같을 때만 다음 요소로 넘어갑니다. 그래서 이들은 완벽한 정렬 키가 됩니다.

#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());  // 나이순, 그다음 이름순

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

필드의 순서가 중요하다는 점에 주목하세요. age를 먼저 두면 주로 나이로 정렬하고, 동률일 때 이름으로 정렬합니다. 이름을 먼저 두는 순서를 원한다면 tuple의 요소 순서를 바꾸면 됩니다. 바로 이 기본 비교 때문에 pair<priority, item>이 우선순위 큐에서 흔히 쓰이는 관용구입니다.

다음: 반복자(Iterator)

이제 컨테이너 주위에서 .first, .second, it->first, *it가 등장하는 것을 보았습니다. pair 요소를 그것이 속한 map과 실제로 이어 주는 것이 바로 _반복자(iterator)_입니다. 다음 페이지에서는 반복자를 제대로 파헤칩니다. begin()과 end()가 정말로 무엇을 반환하는지, ++it가 어떻게 컨테이너를 훑는지, 그리고 C++에서 가장 고약한 미정의 동작을 일으키는 반복자 무효화 함정에 대해 다룹니다.