CODEWITHSUNDEEP
c++referenceintconstants
user3380862
user3380862

Reputation: 133

const reference is bad C++ 11

I was watching Bjarne Stroustrup on YouTube and I was trying to figure out why this is considered bad as he said it is C++98 style bad code

void setInt(const unsigned int &i)
void takeaString(const std::string &str)

I mean you are passing a reference to a constant so you save yourself the copy operation and it isnt even using like passing the pointer so it doesnt have to dereference so why is it bad?

Upvotes: 6

Views: 2081

Answers (2)

bobah
bobah

Reputation: 18864

Here is when it is good:

bool session_exists(heavy_key_t const& key)
{
    // why would we ever want to copy the key if we don't need to
    return sessions.find(key)) == sessions.end();
}

This is when passing argument by reference is possibly not so good:

struct session {
    heavy_key_t key_;
    session(heavy_key_t const& key):
        key_(key) // <-- we are taking a copy anyway, why not letting compiler do it
    {}
};

And another one that works just fine on values thanks to copy elision optimization and RVO:

template <class T, class Merger>
T merge(T state, T update, Merger const& merger) {
    // merger is still by reference, we don't need the copy of it
    return merger(std::move(state), std::move(update));
}

Upvotes: 1

Christian Hackl
Christian Hackl

Reputation: 27518

In pre-C++11, the general rule of thumb is if you don't modify the argument, pass a built-in type by value and an object of a class or struct by const&, because objects of classes or structs are typically so big that passing by const& pays in terms of performance.

Now that's a fairly arbitrary rule, and you'll also see exceptions, of course (e.g. iterators in the standard library) but it works well in practice and is an established idiom. When you see f(int const &i) or f(std::string s) in some other programmer's code, then you will want to know the reason, and if there's no apparent reason, people will be confused.

In C++11, the story may be different. A lot of people claim that due to new language features (move semantics and rvalue references), passing big objects by value is not a performance problem anymore and may even be faster. Look at this article: "Want Speed? Pass by Value." However, when you look at past Stack Overflow discussions, you will also find that there are experienced programmers opposed to this view.

Personally, I've not made up my mind on this. I consider C++11 too new for me to really judge what's good and bad.

Nevertheless, C++11 is often irrelevant if you have to use a pre-C++11 compiler for whatever reason, so it's important to know the pre-C++11 rules in any case.

Upvotes: 7

Related Questions