F.16 (pass by reference to const / by value): Request for clarification about cppcoreguidelines HOT 6 OPEN

Hi @beinhaerter, may I ask you double-check the snippet, please? I think that the lvalue in the last std::cout should be rvalue.

Thanks for pointing that out. I corrected the code snippet.

from cppcoreguidelines.

@iglesias

[...] I'd follow the approach in your first bullet point [...]

Taking the argument by reference to const and then creating a copy is less efficient
if the caller passes an rvalue to the function
because that creates copy, whereas taking the argument by value would move.

from cppcoreguidelines.

Hi, I can't sure what you are missing or misunderstanding, although your explanations dealing with rvalue (reference(s)) are not clear to me. This also pertains your third and fourth questions.

I don't think your use case is so exotic and to comply with the guideline as it is I'd follow the approach in your first bullet point: I think that, if I am understanding you correctly,

auto f(T const& t) {
  // This would be what you called little bit more code, correct? Strictly, with the const& too.
  auto t_copy = t;
  ...
}

is not in fact "tiny bit more"(?) complicated code than

auto f(T t) {
  ...
}

from cppcoreguidelines.

@iglesias siebenschlaefer said that the const& code is less efficient when you pass an rvalue to it. You can compare it using the code below.

I agree with @siebenschlaefer and that is why I am using this pass-by-value approach in my code, too. Contradicting 'F.18: For “will-move-from” parameters, pass by X&& and std::move the parameter' I even use that for will-move-from parameters to give the caller of my function more freedom and to not require him to std::move().

#include <iostream>

struct S {
    S() { std::cout << "ctor\n"; }
    S(const S&) { std::cout << "copy ctor\n"; }
    S(S&&) { std::cout << "move ctor\n"; }
};

S get() noexcept { return S{}; }

void fc(const S& s) { S copy{s}; }

void fr(S&& s) {}

void fv(S s) {}

int main() {
    S s;
    std::cout << "\nf taking const&, getting lvalue\n";
    fc(s);
    std::cout << "\nf taking const&, getting rvalue\n";
    fc(get());
    std::cout << "\n\nf taking rvalue\n";
    fr(get());
    std::cout << "\n\nf taking value, getting lvalue\n";
    fv(s);
    std::cout << "\nf taking value, getting rvalue\n";
    fv(get());
}

from cppcoreguidelines.

Hi @beinhaerter, may I ask you double-check the snippet, please? I think that the lvalue in the last std::cout should be rvalue.

Disregarding that and assuming the snippet's point is correct. I feel that better measurement is needed to reach the conclusion that it is less efficient.

from cppcoreguidelines.

Editors call: Thanks! We intend to update the wording to cover this case better.

from cppcoreguidelines.