C++ STL Pairs and Tuples Explained — With Real Examples

#include <iostream>
#include <utility>   // std::pair, std::make_pair
#include <string>
#include <vector>
#include <algorithm> // std::sort

int main() {
    // ── 1. Three ways to create a pair ──────────────────────────────────────

    // Method A: Explicit constructor — you spell out both types yourself
    std::pair<std::string, int> playerScore("Alice", 4200);

    // Method B: make_pair — compiler infers the types; less typing, same result
    auto cityPopulation = std::make_pair(std::string("Tokyo"), 13960000);

    // Method C: Brace initialisation (C++17) — clean and modern
    std::pair<std::string, double> productPrice = {"Keyboard", 79.99};

    // ── 2. Accessing elements with .first and .second ────────────────────────
    std::cout << "Player: " << playerScore.first
              << ", Score: " << playerScore.second << "\n";

    std::cout << "City: " << cityPopulation.first
              << ", Population: " << cityPopulation.second << "\n";

    std::cout << "Product: " << productPrice.first
              << ", Price: $" << productPrice.second << "\n";

    // ── 3. Modifying values after creation ───────────────────────────────────
    playerScore.second += 800;  // Alice just scored 800 more points
    std::cout << "Updated score: " << playerScore.second << "\n";

    // ── 4. Sorting a vector of pairs (lexicographic by default) ──────────────
    std::vector<std::pair<std::string, int>> leaderboard = {
        {"Carlos", 3100},
        {"Alice",  4200},
        {"Bob",    3100},   // Same score as Carlos — name decides tie
        {"Diana",  5500}
    };

    // std::sort uses operator< on pairs: sorts by .first, then .second
    std::sort(leaderboard.begin(), leaderboard.end());

    std::cout << "\nLeaderboard (sorted by name, then score):\n";
    for (const auto& entry : leaderboard) {
        std::cout << "  " << entry.first << " — " << entry.second << "\n";
    }

    // ── 5. Sort by score descending — provide a custom comparator lambda ─────
    std::sort(leaderboard.begin(), leaderboard.end(),
        [](const auto& a, const auto& b) {
            return a.second > b.second;  // higher score first
        }
    );

    std::cout << "\nLeaderboard (sorted by score, highest first):\n";
    for (const auto& entry : leaderboard) {
        std::cout << "  " << entry.first << " — " << entry.second << "\n";
    }

    return 0;
}

#include <iostream>
#include <tuple>    // std::tuple, std::make_tuple, std::get, std::tie
#include <string>
#include <vector>
#include <algorithm>

// ── Helper: returns a student record as a tuple ──────────────────────────────
// Returning a tuple from a function is a clean way to return multiple values
// without writing a dedicated struct.
std::tuple<std::string, char, double> buildStudentRecord(
    const std::string& name, char grade, double gpa)
{
    return std::make_tuple(name, grade, gpa);
}

int main() {
    // ── 1. Create a tuple ────────────────────────────────────────────────────
    auto studentRecord = std::make_tuple(std::string("Maria"), 'A', 3.91);

    // ── 2. Access elements the old way: std::get<index> ─────────────────────
    std::cout << "Name:  " << std::get<0>(studentRecord) << "\n";
    std::cout << "Grade: " << std::get<1>(studentRecord) << "\n";
    std::cout << "GPA:   " << std::get<2>(studentRecord) << "\n";

    // ── 3. Access by TYPE — works only when the type is unique in the tuple ──
    double gpa = std::get<double>(studentRecord); // unambiguous: only one double
    std::cout << "GPA via type lookup: " << gpa << "\n";

    // ── 4. Structured bindings (C++17) — the modern, readable way ────────────
    auto [studentName, letterGrade, gradePoint] = studentRecord;
    std::cout << "\nStructured binding unpacked:\n";
    std::cout << studentName << " got grade " << letterGrade
              << " with GPA " << gradePoint << "\n";

    // ── 5. std::tie — useful when you already have declared variables ─────────
    // std::tie binds variables to tuple elements by reference.
    // Use std::ignore to skip elements you don't need.
    std::string extractedName;
    double      extractedGpa;
    std::tie(extractedName, std::ignore, extractedGpa) = studentRecord;
    std::cout << "\nExtracted with tie: " << extractedName
              << " — " << extractedGpa << "\n";

    // ── 6. Returning a tuple from a function ─────────────────────────────────
    auto record2 = buildStudentRecord("James", 'B', 3.40);
    auto [name2, grade2, gpa2] = record2;  // unpack immediately
    std::cout << "\nFrom function: " << name2 << " | "
              << grade2 << " | " << gpa2 << "\n";

    // ── 7. Sorting a vector of tuples ────────────────────────────────────────
    // Tuples compare lexicographically just like pairs.
    // Here we sort students by GPA descending.
    std::vector<std::tuple<std::string, char, double>> classRoster = {
        {"Maria", 'A', 3.91},
        {"James", 'B', 3.40},
        {"Priya", 'A', 3.95},
        {"Leo",   'C', 2.88}
    };

    // Custom comparator: compare the third element (index 2) in descending order
    std::sort(classRoster.begin(), classRoster.end(),
        [](const auto& a, const auto& b) {
            return std::get<2>(a) > std::get<2>(b);  // higher GPA first
        }
    );

    std::cout << "\nClass sorted by GPA (highest first):\n";
    for (const auto& [sName, sGrade, sGpa] : classRoster) {
        std::cout << "  " << sName << " | " << sGrade << " | " << sGpa << "\n";
    }

    return 0;
}

#include <iostream>
#include <map>
#include <set>
#include <string>
#include <tuple>
#include <utility>

// ── Pattern 1: std::pair as a 2D map key (e.g., memoisation / grid lookup) ───
void demonstrate2DMapKey() {
    std::cout << "=== Pattern 1: Pair as 2D Map Key ===\n";

    // Stores the shortest distance between two city IDs
    std::map<std::pair<int,int>, double> distanceCache;

    distanceCache[{1, 2}] = 312.5;   // distance from city 1 to city 2
    distanceCache[{1, 3}] = 98.0;
    distanceCache[{2, 3}] = 245.7;

    // Query the cache
    auto key = std::make_pair(1, 3);
    if (distanceCache.count(key)) {
        std::cout << "Distance 1→3: " << distanceCache[key] << " km\n";
    }
}

// ── Pattern 2: Reading the return value of map::insert ───────────────────────
void demonstrateInsertReturn() {
    std::cout << "\n=== Pattern 2: map::insert Return Value ===\n";

    std::map<std::string, int> wordFrequency;

    // insert() returns a pair<iterator, bool>
    // .second == true  → insertion happened (key was new)
    // .second == false → key already existed, nothing changed
    auto [iterator1, wasInserted1] = wordFrequency.insert({"hello", 1});
    std::cout << "Inserted 'hello': " << (wasInserted1 ? "yes" : "no") << "\n";

    auto [iterator2, wasInserted2] = wordFrequency.insert({"hello", 99});
    std::cout << "Re-inserted 'hello': " << (wasInserted2 ? "yes" : "no") << "\n";
    std::cout << "Actual value: " << wordFrequency["hello"] << "\n"; // still 1
}

// ── Pattern 3: Returning multiple values cleanly from a function ──────────────
struct HttpResponse {  // For PERMANENT groupings, prefer a named struct
    int    statusCode;
    std::string body;
    double latencyMs;
};

// For TEMPORARY groupings (one-off), a tuple is fine
std::tuple<bool, std::string, int> parseUserInput(const std::string& raw) {
    if (raw.empty()) {
        return {false, "Input cannot be empty", -1};
    }
    // Pretend we parsed the input successfully
    return {true, raw, static_cast<int>(raw.size())};
}

void demonstrateMultiReturn() {
    std::cout << "\n=== Pattern 3: Multi-value Return ===\n";

    auto [success, message, length] = parseUserInput("hello world");
    if (success) {
        std::cout << "Parsed OK: '" << message << "' (" << length << " chars)\n";
    }

    auto [ok, err, len] = parseUserInput("");
    if (!ok) {
        std::cout << "Parse failed: " << err << "\n";
    }
}

int main() {
    demonstrate2DMapKey();
    demonstrateInsertReturn();
    demonstrateMultiReturn();
    return 0;
}