tuple

---

1. Storing Heterogeneous Data

tuple<int, string, bool> myTuple = make_tuple(10, "John", true);

2. Returning Multiple Values from a Function

tuple<int, string> getDetails() {
  return make_tuple(10, "John");
}

3. Passing Multiple Arguments to a Function

void printTuple(tuple<int, string>) {
  // ...
}

4. Swapping Elements

tuple<int, string> myTuple = make_tuple(10, "John");
get<0>(myTuple) = 20; // swaps the first element

5. Element Access

tuple<int, string, bool> myTuple = make_tuple(10, "John", true);
int age = get<0>(myTuple);
string name = get<1>(myTuple);

6. Iterate Over Elements

tuple<int, string, bool> myTuple = make_tuple(10, "John", true);
for (auto& element : myTuple) {
  cout << element << " ";
}

7. Comparing Tuples

tuple<int, string, bool> myTuple1 = make_tuple(10, "John", true);
tuple<int, string, bool> myTuple2 = make_tuple(10, "John", false);
bool isEqual = (myTuple1 == myTuple2);

8. Sorting Tuples (lexicographical)

vector<tuple<int, string>> myTuples = {make_tuple(10, "John"), make_tuple(5, "Peter")};
sort(myTuples.begin(), myTuples.end());

9. Merging Tuples

tuple<int, string> myTuple1 = make_tuple(10, "John");
tuple<bool, char> myTuple2 = make_tuple(true, 'A');
auto mergedTuple = tuple_cat(myTuple1, myTuple2);

10. Function Pointers

tuple<void (*)(int), void (*)(string)> myTuple = make_tuple(
  [](int x) { cout << x; },
  [](string s) { cout << s; }
);

11. Lambda Expressions

tuple<auto, auto> myTuple = make_tuple(
  []() -> int { return 10; },
  []() -> string { return "John"; }
);

12. Unpack Tuples

int age;
string name;
tuple<int, string> myTuple = make_tuple(10, "John");
tie(age, name) = myTuple;

13. Accessing Elements by Names

struct Student { string name; int age; };
using StudentTuple = tuple<string, int, char>;
StudentTuple myTuple = make_tuple("John", 10, 'A');
string name = get<Student.name>(myTuple);

14. Custom Data Structures with Tuples

struct Book { string title; string author; int pages; };
Book b = {"The Hobbit", "J.R.R. Tolkien", 295};
tuple<Book, bool, double> myData = make_tuple(b, true, 9.99);

15. Array of Tuples

tuple<int, string>[5] myArray = {
  make_tuple(10, "John"),
  make_tuple(5, "Peter"),
  make_tuple(7, "Susan"),
  make_tuple(9, "David"),
  make_tuple(11, "Emily")
};

16. Tuple as a Map Key

unordered_map<tuple<int, string>, string> myMap;
myMap[make_tuple(10, "John")] = "John Doe";

17. Set of Tuples

set<tuple<int, string>> mySet;
mySet.insert(make_tuple(10, "John"));
mySet.insert(make_tuple(5, "Peter"));

18. Tuple with Unordered Elements

using UTuple = tuple<int, string, bool, optional<double>>;
UTuple myTuple = make_tuple(10, "John", true, nullopt);

19. Tuple as a Class Member

class Person {
public:
  Person(string name, int age) : name(name), age(age) {}
  tuple<string, int> getInfo() const { return make_tuple(name, age); }

private:
  string name;
  int age;
};

20. Index a Tuple

tuple<int, string, bool> myTuple = make_tuple(10, "John", true);
int index = 1;
auto element = get<index>(myTuple);

21. Pair

pair<int, string> myPair = make_pair(10, "John");

22. Tuple of Arrays

tuple<int[], string[], bool[]> myTuple = make_tuple(
  {1, 2, 3}, {"John", "Peter", "Susan"},
  {true, false, true}
);

23. Tuple of Vectors

tuple<vector<int>, vector<string>, vector<bool>> myTuple = make_tuple(
  {1, 2, 3}, {"John", "Peter", "Susan"},
  {true, false, true}
);

24. Tuple of Sets

tuple<set<int>, set<string>, set<bool>> myTuple = make_tuple(
  {1, 2, 3}, {"John", "Peter", "Susan"},
  {true, false, true}
);

25. Tuple of Maps

tuple<map<int, string>, map<string, int>, map<string, bool>> myTuple = make_tuple(
  {{1, "John"}, {2, "Peter"}, {3, "Susan"}},
  {{"John", 1}, {"Peter", 2}, {"Susan", 3}},
  {{"John", true}, {"Peter", false}, {"Susan", true}}
);

26. Tuple of Lists

tuple<list<int>, list<string>, list<bool>> myTuple = make_tuple(
  {1, 2, 3}, {"John", "Peter", "Susan"},
  {true, false, true}
);

27. Tuple of Unordered Sets

tuple<unordered_set<int>, unordered_set<string>, unordered_set<bool>> myTuple = make_tuple(
  {1, 2, 3}, {"John", "Peter", "Susan"},
  {true, false, true}
);

28. Tuple of Unordered Maps

tuple<unordered_map<int, string>, unordered_map<string, int>, unordered_map<string, bool>> myTuple = make_tuple(
  {{1, "John"}, {2, "Peter"}, {3, "Susan"}},
  {{"John", 1}, {"Peter", 2}, {"Susan", 3}},
  {{"John", true}, {"Peter", false}, {"Susan", true}}
);

29. Tuple of C-Style Arrays

tuple<int*, string*, bool*> myTuple = make_tuple(
  new int[3]{1, 2, 3},
  new string[3]{"John", "Peter", "Susan"},
  new bool[3]{true, false, true}
);

30. Tuple of Pointers

tuple<int*, string*, bool*> myTuple = make_tuple(
  new int{10}, new string{"John"}, new bool{true}
);

31. Tuple of References

int a = 10;
string b = "John";
bool c = true;
tuple<int&, string&, bool&> myTuple = make_tuple(a, b, c);

32. Tuple of Smart Pointers

tuple<unique_ptr<int>, unique_ptr<string>, unique_ptr<bool>> myTuple = make_tuple(
  make_unique<int>(10), make_unique<string>("John"), make_unique<bool>(true)
);

33. Tuple of Function Objects

tuple<function<int(int)>, function<string(string)>, function<bool(bool)>> myTuple = make_tuple(
  [](int x) { return x + 1; },
  [](string s) { return s + "!"; },
  [](bool b) { return !b; }
);

34. Tuple of Iterators

vector<int> v = {1, 2, 3};
tuple<vector<int>::iterator, vector<int>::iterator> myTuple =
  make_tuple(v.begin(), v.end());

35. Tuple of Range-based for Control Variable

tuple<int, string> myTuple;
for (auto& [x, y] : myTuple) {
  // ...
}

36. Tuple as a Function Argument

void foo(const tuple<int, string>& myTuple) {
  // ...
}

37. Tuple as a Function Return Value

tuple<int, string> foo() {
  return make_tuple(10, "John");
}

38. Tuple as an Aggregate Initializer

struct Person {
  int age;
  string name;
};
Person p = {10, "John"};

39. Tuple as a Struct Member

struct Person {
  int age;
  string name;
  tuple<int, string> getDetails() const { return make_tuple(age, name); }
};

40. Tuple as a Class Template

template<typename T1, typename T2>
struct Pair {
  tuple<T1, T2> data;
};

41. Tuple as a C-Style Union

#define UNION(T1, T2) \
  union { \
    T1 t1; \
    T2 t2; \
  }

42. Tuple as a Type Family

template<typename T>
struct TupleSize {
  static const size_t value = tuple_size<T>::value;
};

43. Tuple as a Template Metaprogramming Tool

template<typename T, typename... Ts>
struct PushFront {
  typedef tuple<T, Ts...> type;
};

44. Tuple as a Syntax Sugar

#define PAIR(T1, T2) make_pair(T1, T2)

45. Tuple as a Data Wrangling Tool

tuple<int, string> myTuple = make_tuple(10, "John");
auto [age, name] = myTuple;

46. Tuple as a State Machine

template<typename State>
struct StateMachine {
  tuple<State, string> handleInput(char c) {
    switch (get<0>(state)) {
    // ...
    }
  }

private:
  State state;
};

47. Tuple as a Custom Container

template<typename... Ts>
class MyContainer {
public:
  MyContainer(Ts&&... args) : tuple(std::forward<Ts>(args)...) {}

  // ...
};

48. Tuple as a Data Transfer Object

struct PersonDTO {
  int id;
  string name;
  int age;
};

49. Tuple as a Command Queue

tuple<string, function<void()>> myCommandQueue = make_tuple("foo", []() { /* ... */ });

50. Tuple as a Cache

unordered_map<int, tuple<int, string>> myCache;