std::tie(3)

NAME
std::tie - std::tie

Synopsis
   Defined in header <tuple>
   template< class... Types > (since C++11)
   std::tuple<Types&...> tie( Types&... args ) noexcept; (until C++14)
   template< class... Types > (since C++14)
   constexpr std::tuple<Types&...> tie( Types&... args ) noexcept;
   Creates a tuple of lvalue references to its arguments or instances of std::ignore.

Parameters
   args - zero or more lvalue arguments to construct the tuple from.

Return value
   A std::tuple object containing lvalue references.

Possible implementation
   template <typename... Args>
   constexpr // since C++14
   std::tuple<Args&...> tie(Args&... args) noexcept {
       return {args...};
   }

Notes
   std::tie may be used to unpack a std::pair because std::tuple has a converting
   assignment from pairs:
 bool result;
 std::tie(std::ignore, result) = set.insert(value);

Example
   std::tie can be used to introduce lexicographical comparison to a struct or to
   unpack a tuple: // Run this code
 #include <iostream>
 #include <string>
 #include <set>
 #include <tuple>
 struct S {
     int n;
     std::string s;
     float d;
     bool operator<(const S& rhs) const
     {
         // compares n to rhs.n,
         // then s to rhs.s,
         // then d to rhs.d
         return std::tie(n, s, d) < std::tie(rhs.n, rhs.s, rhs.d);
     }
 };
 int main()
 {
     std::set<S> set_of_s; // S is LessThanComparable
     S value{42, "Test", 3.14};
     std::set<S>::iterator iter;
     bool inserted;
     // unpacks the return value of insert into iter and inserted
     std::tie(iter, inserted) = set_of_s.insert(value);
     if (inserted)
         std::cout << "Value was inserted successfully\n";
 }

Output:
 Value was inserted successfully

See also
   Structured binding (C++17) binds the specified names to sub-objects or tuple
                        elements of the initializer
   make_tuple creates a tuple object of the type defined by the
   (C++11) argument types
                        (function template)
   forward_as_tuple creates a tuple of forwarding references
   (C++11) (function template)
   tuple_cat creates a tuple by concatenating any number of tuples
   (C++11) (function template)
   ignore placeholder to skip an element when unpacking a tuple
   (C++11) using tie
                        (constant)