What is use of the ref-qualifier `const &&`?

by

On the usefulness of const&&… (in general)

The usefulness of the const&& qualifier on the member method is minimal at best. The object cannot be modified in the same manner as a && method would allow it to be modified; it is const after all (as noted, mutable does change this). So we will not be able to rip out its guts, since the temporary is expiring anyway, as we would in something akin to a normal move.

In many ways the usefulness of the const&& may be best evaluated in the context of how useful an object of type const T&& is to begin with. How useful is a const T&& function argument? As pointed out in another answer (to this question) here, they are very useful in declaring functions deleted, e.g. in this case

template <class T> void ref (const T&&) = delete;

to explicitly disallow objects of prvalue and xvalue value category types from being used with the functions, and const T&& does bind to all prvalue and xvalue objects.

What is the usefulness of const&& method qualifier?

It is interesting to note that in the proposal C++ library extensions, optional, ยง 5.3, includes overloads, e.g.

constexpr T value() const &&;

that are qualified as const&& and are specified to perform the same action as the && alternative.

The reason I can infer for this case; is that this is for completeness and correctness. If the value() method is called on an rvalue, then it performs the same action independent of it being const or not. The const will need to be dealt with by the contained object being moved or the client code using it. If there is some mutable state with the object being contained, then that state can legitimately be changed.

There may well still be some merit in this; in no particular order…

  • To declare it = delete to prohibit the method’s use on prvalues and xvalues.
  • If the type has mutable state and the qualifier makes sense (possibly in addition to the other qualifiers) in the target environment, consider it.
  • If you are implementing a generic container type, then for completeness and correctness, consider adding it and performing the same action as the && method. Advice here is sort from the standard library (and its extensions).

What would a “canonical” signature look like for a const&& qualified method?

Since the method will be performing the same action as the && method, I would advocate that the signature matches the && signature.

More Related Contents:

  1. C++11 rvalues and move semantics confusion (return statement)
  2. Why is `std::move` named `std::move`?
  3. Is a moved-from vector always empty?
  4. Is the pass-by-value-and-then-move construct a bad idiom?
  5. How to actually implement the rule of five?
  6. Is it possible to std::move objects out of functions? (C++11)
  7. Why do some people use swap for move assignments?
  8. Can I typically/always use std::forward instead of std::move?
  9. Is there any case where a return of a RValue Reference (&&) is useful?
  10. push_back vs emplace_back
  11. What does T&& (double ampersand) mean in C++11?
  12. What is std::move(), and when should it be used?
  13. A positive lambda: ‘+[]{}’ – What sorcery is this? [duplicate]
  14. reinterpret_cast creating a trivially default-constructible object
  15. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  16. What constitutes a valid state for a “moved from” object in C++11?
  17. When is a private constructor not a private constructor?
  18. Syntax for universal references
  19. Matching alias template as template argument
  20. In C++, what categories (lvalue, rvalue, xvalue, etc.) can expressions that produce temporaries of class type fall into?
  21. Lambda capture and parameter with same name – who shadows the other? (clang vs gcc)
  22. Non-copyable elements in vector
  23. Passing rvalues through std::bind
  24. Move or Named Return Value Optimization (NRVO)?
  25. Legal to overwrite std::string’s null terminator?
  26. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  27. Calling an explicit constructor with a braced-init list: ambiguous or not?
  28. std::tuple memory alignment
  29. Rvalues, lvalues and formal definitions
  30. Overload resolution with ref-qualifiers

Leave a Comment