c++11: given f(const X&) and f(X&&), do we ever need f(X&)?

Question

The title says it all.

The first case f(const X&) is the good old fashioned const reference parameter.

However, when taking a mutable reference parameter, why not always use X&&? This way client code can use temps or regular lvalues, rather than f() dictating usage.

EDIT: Sloppiness on my part, sorry. I meant, given fc(const X&) and fm(X&&), do we need fm(X&)?

EDIT: Example: I use stateless decorators to pass as parameters:

class Base64Writer: public Writer {
public:
  Base64Writer(Writer& w): w_(w) {}
private:
  virtual void doWrite() override;
  Writer& w_;
}

void func(Writer&& w) { w.doWrite(); }

// to be called as
Writer wr = ...;
func(Base64Writer(wr));

Answer 1

• If you mean to ask : is it logical to have all three overloads at the same time?

  In most cases, it would be a bad idea. as the semantic of the overloaded functions contradict each other. One promises that it will not modify the argument, the other doesn't make any such promise (it tacitly says it will modify the argument!). The user of such overloaded functions will be confused that differs only by const.

  It makes sense to have these overloads at the same time:

  void process(std::vector<int> const&);
  void process(std::vector<int> &&);
  

  But a third one, in addition to the above two, doesn't make much sense to me:

  void process(std::vector<int> &); //contradicts the first overload
  

  It only adds confusion and makes code harder to read. If you want this semantic, choose a different name for the function!

• If you mean to ask : which one should you have (though not necessarily all at the same time)?

  I would say, it depends on the semantic. If the parameter behaves as input and/or output parameter, then f(X&) makes sense. If the parameter is only input parameter, then f(X const&) makes sense, in this case you can additionally define f(X&&) also, to gain performance advantage!

Answer 2

Absolutely!

For example, you need it whenever you're manipulating a container passed as an argument.

In fact, you might need all three -- compare these, for example:

vector<int> append_if_not_ends_with(vector<int> const &original, int x)
{
    vector<int> v(original);
    if (v.empty() || v.back() != x)
    { v.push_back(x); }
    return v;
}

vector<int> &append_if_not_ends_with(vector<int> &v, int x)
{
    if (v.empty() || v.back() != x)
    { v.push_back(x); }
    return v;
}

vector<int> append_if_not_ends_with(vector<int> &&original, int x)
{
    vector<int> v(std::move(original));
    if (v.empty() || v.back() != x)
    { v.push_back(x); }
    return v;
}

If you have all 3 overloads, then you can avoid copying the contents of the vector when you don't need to.

vector<int> v1;
vector<int> const &v2 =
    foo ? append_if_not_ends_with(v1) :
    bar ? append_if_not_ends_with(static_cast<vector<int> const &>(v1)) :
          append_if_not_ends_with(vector<int>());

Answer 3

I am surprised that nobody pointed out that you can actually pass by value, and that this practice in c++11 is actually the right thing to do whenever you think that you need f(X&&).

Imo:

• Use f(const X &) if you need just to read from the element.
• Use f(X) if you need to take the ownership of the object passed. The caller of your function can just do f( std::move(something)) or f(something) when appropriate.
• Use f(X&) if you need to modify the passed object.