structured binding with [[maybe_unused]]

by

In the structure bindings paper:

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0144r2.pdf

they discuss their reasoning:

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.

Although this does not explicitly address [[maybe_unused]], I assume the reasoning might be the same. Stopping compiler warnings is not a use-case.

More Related Contents:

  1. Lambda implicit capture fails with variable declared from structured binding
  2. structured bindings: when something looks like a reference and behaves similarly to a reference, but it’s not a reference
  3. std::ignore with structured bindings?
  4. What are use cases for structured bindings?
  5. what is the concept of evaluation of expression z = (y = 30) + (y = 10) + (y = 20); [closed]
  6. What are Aggregates and PODs and how/why are they special?
  7. reinterpret_cast creating a trivially default-constructible object
  8. Advantages of auto in template parameters in C++17
  9. What are template deduction guides and when should we use them?
  10. Difference between “if constexpr()” Vs “if()”
  11. Strongly typed using and typedef
  12. How is P0522R0 breaking code?
  13. Simplest way to determine return type of function
  14. Link errors using members in C++17
  15. Does the behavior of guaranteed copy elision depend on existence of user-defined copy constructor?
  16. Can std::launder be used to convert an object pointer to its enclosing array pointer?
  17. Compile-time or runtime detection within a constexpr function
  18. Are C++17 Parallel Algorithms implemented already?
  19. Partial class template argument deduction in C++17
  20. “constexpr if” vs “if” with optimizations – why is “constexpr” needed?
  21. How do you implement Coroutines in C++
  22. Why isn’t RVO applied to base class subobject initialization?
  23. Using std::string_view with api that expects null-terminated string
  24. How to enable /std:c++17 in VS2017 with CMake
  25. Undefined reference error for static constexpr member
  26. What are the differences between std::variant and boost::variant?
  27. What changes to C++ made copy initialization work for class with explicit constructor?
  28. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?
  29. Check if a type is passed in variadic template parameter pack
  30. ‘std::filesystem’ has not been declared after including

Leave a Comment