std::ignore with structured bindings?

by

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.

Symmetry with std::tie would suggest using something like a std::ignore:

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 _ or *, 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 std::tie uses std::ignore.

More Related Contents:

  1. structured bindings: when something looks like a reference and behaves similarly to a reference, but it’s not a reference
  2. reinterpret_cast creating a trivially default-constructible object
  3. Is stateful metaprogramming ill-formed (yet)?
  4. What made i = i++ + 1; legal in C++17?
  5. Is a pointer with the right address and type still always a valid pointer since C++17?
  6. How is P0522R0 breaking code?
  7. Lambda implicit capture fails with variable declared from structured binding
  8. Deducing first template argument with other template parameters defaulted
  9. Does the behavior of guaranteed copy elision depend on existence of user-defined copy constructor?
  10. Self-initialization of a static constexpr variable, is it well-formed?
  11. Can std::launder be used to convert an object pointer to its enclosing array pointer?
  12. Static member access in constant expressions
  13. Pointer interconvertibility vs having the same address
  14. structured binding with [[maybe_unused]]
  15. Why doesn’t an if constexpr make this core constant expression error disappear?
  16. What are use cases for structured bindings?
  17. Is it allowed for a compiler to optimize away a local volatile variable?
  18. Will I be able to declare a constexpr lambda inside a template parameter?
  19. What changes to C++ made copy initialization work for class with explicit constructor?
  20. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?
  21. Directly write into char* buffer of std::string
  22. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  23. When using C headers in C++, should we use functions from std:: or the global namespace?
  24. Matching alias template as template argument
  25. Why does same_as concept check type equality twice?
  26. Link errors using members in C++17
  27. Is std::abs(0u) ill-formed?
  28. Does accessing the first field of a struct via a C cast violate strict aliasing?
  29. C++ – Why static member function can’t be created with ‘const’ qualifier
  30. Is a constexpr array necessarily odr-used when subscripted?

Leave a Comment