std::tuple<int, int, int> f();
std::tuple<int, int, float, int> g();
int a, b, c;
std::tie(a, b, c) = f();
auto [a, b, c] = f();
std::tie(a, b, std::ignore, c) = g();
The structured bindings proposal contains a dedicated section answering your question (P0144R2):
3.8 Should there be a way to explicitly ignore components?
The motivation would be to silence compiler warnings about unused names. We think the answer should be “not yet.” This is not motivated by use cases (silencing compiler warnings is a motivation, but it is not a use case per se), and is best left until we can revisit this in the context of a more general pattern matching proposal where this should fall out as a special case.
std::tiewould suggest using something like a
tuple<T1,T2,T3> f(); auto [x, std::ignore, z] = f(); // NOT proposed: ignore second element
However, this feels awkward.
Anticipating pattern matching in the language could suggest a wildcard like
*, but since we do not yet have pattern matching it is premature to pick a syntax that we know will be compatible. This is a pure extension that can wait to be considered with pattern matching.
However, note that the working draft of the Standard is currently being revised by the relevant National Bodies (NB), and there is a NB comment requesting this feature (P0488R0, US100):
Decomposition declarations should provide syntax to discard some of the returned values, just as