std::tie
From cppreference.com
C++
Feature test macros (C++20)
Concepts library (C++20)
Metaprogramming library (C++11)
Ranges library (C++20)
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Utilities library
Type support (basic types, RTTI)
Library feature-test macros (C++20)
(C++11)
(C++20)
(C++26)
(C++20)
Coroutine support (C++20)
Contract support (C++26)
(C++20)(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)(C++20)(C++20)
(C++20)(C++20)(C++20)
General utilities
Relational operators (deprecated in C++20)
(C++20)(C++20)(C++20)
(C++20)(C++20)(C++20)
(C++20)
Swap and type operations
Common vocabulary types
std::tuple
tie
(until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)
(C++23)
(C++23)
(C++23)
Deduction guides (C++17)
Defined in header
<tuple>
template< class... Types >
std::tuple <Types&...> tie( Types&... args ) noexcept;
(since C++11) std::tuple <Types&...> tie( Types&... args ) noexcept;
(constexpr since C++14)
Creates a tuple of lvalue references to its arguments or instances of std::ignore .
[edit] Parameters
args
-
zero or more lvalue arguments to construct the tuple from.
[edit] Return value
A std::tuple object containing lvalue references.
[edit] Possible implementation
template <typename... Args> constexpr // since C++14 std::tuple <Args&...> tie(Args&... args) noexcept { return {args...}; }
[edit] 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);
[edit] Example
1) std::tie
can be used to introduce lexicographical comparison to a struct or to unpack a tuple;
2) std::tie
can work with structured bindings:
Run this code
#include <cassert> #include <iostream> #include <set> #include <string> #include <tuple> struct S { int n; std::string s; float d; friend bool operator<(const S& lhs, const S& rhs) noexcept { // compares lhs.n to rhs.n, // then lhs.s to rhs.s, // then lhs.d to rhs.d // in that order, first non-equal result is returned // or false if all elements are equal return std::tie(lhs.n, lhs.s, lhs.d) < std::tie(rhs.n, rhs.s, rhs.d); } }; int main() { // Lexicographical comparison demo: std::set <S> set_of_s; S value{42, "Test", 3.14}; std::set <S>::iterator iter; bool is_inserted; // Unpack a pair: std::tie(iter, is_inserted) = set_of_s.insert(value); assert (is_inserted); // std::tie and structured bindings: auto position = [](int w) { return std::tuple (1 * w, 2 * w); }; auto [x, y] = position(1); assert (x == 1 && y == 2); std::tie(x, y) = position(2); // reuse x, y with tie assert (x == 2 && y == 4); // Implicit conversions are permitted: std::tuple <char, short> coordinates(6, 9); std::tie(x, y) = coordinates; assert (x == 6 && y == 9); // Skip an element: std::string z; std::tie(x, std::ignore, z) = std::tuple (1, 2.0, "Test"); assert (x == 1 && z == "Test"); }
[edit] See also
Structured binding (C++17)
binds the specified names to sub-objects or tuple elements of the initializer[edit]