Is there any real use case for function's reference qualifiers?

Question

Recently I learned about function's reference qualifiers, e.g.

struct foo
{
    void bar() {}
    void bar1() & {}
    void bar2() && {}
};

Where I might need this feature, is there any real use case for this language feature ?

Answer 1

Where I might need this feature, is there any real use case for this language feature ?

The example you show is pretty useless, it's more useful when you have an overloaded function, one version that operates on lvalues and one that operates on rvalues.

Consider a type a bit like std::stringstream that owns a string and returns it by value. If the object is an rvalue, it can move the string instead of copying it.

class StringBuilder
{
public:
  std::string get() const& { return m_str; }
  std::string get() && { return std::move(m_str); }

private:
  std::string m_str;
};

This means when you return a StringBuilder from a function and want to get the string out of it, you don't need a copy:

std::string s = buildString().get();

More generally, given a function f(const X&) if it would be useful to overload it with f(X&&), then given a member function X::f() it might be useful to change it to X::f() const& and overload it with X::f()&&