structured bindings: when something looks like a reference and behaves similarly to a reference, but it’s not a reference

by

I wrote this yesterday:

decltype(x), where x is a structured binding, names the referenced
type of that structured binding. In the tuple-like case, this is the
type returned by std::tuple_element, which may not be a reference
even though the structured binding itself is in fact always a
reference in this case. This effectively emulates the behavior of
binding to a struct whose non-static data members have the types
returned by tuple_element, with the referenceness of the binding
itself being a mere implementation detail.

More Related Contents:

  1. std::ignore with structured bindings?
  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. How does guaranteed copy elision work?
  23. Where exactly does C++ standard say dereferencing an uninitialized pointer is undefined behavior?
  24. static_assert dependent on non-type template parameter (different behavior on gcc and clang)
  25. How many levels of pointers can we have?
  26. constexpr static member before/after C++17
  27. Try to understand compiler error message: default member initializer required before the end of its enclosing class
  28. Is it UB to access a member by casting an object pointer to `char *`, then doing `*(member_type*)(pointer + offset)`?
  29. Why is modifying a string through a retrieved pointer to its data not allowed?
  30. What is difference between const and non const key?

Leave a Comment