Which set methods has better performance: with or without `const&`?

Question

Which set methods has better performance in compiler supporting right-value: with or without const&? For example

class A
{
public:
    void setProperty(Property const& p)   {m_property = p;}
    void setProperty(Property p)          {m_property = p;}
};

Or is keeping both okay? Here Property is a large class. The refactor tool in Visual Assist X use the second one without const&.

[See here.](http://stackoverflow.com/questions/3106110/what-is-move-semantics) Though it might be a little beyond the scope of the question. But the point is that you can provide an overload that will allow a movable object to be moved all the way into `m_property` without any copies. — Mysticial, Jul 29 '13 at 02:29

Casey · Answer 1 · 2013-07-29T03:01:24.147

Write the setter to take a const&:

void setProperty(Property const& p) {m_property = p;}

and in C++11, write an overload that takes && as well:

void setProperty(Property&& p) {m_property = std::move(p);}

It's nice to use the "shortcut" method of writing a single overload that takes the property by value:

void setProperty(Property p) {m_property = std::move(p);}

but be aware that when passed an lvalue, this requires memory to be allocated simultaneously for 3 objects - the original, the member, and the parameter - for a short time.

If you're feeling especially jaunty, you can amaze your friends and family by writing a perfect forwarding setter:

template <typename T>
void setProperty(T&& t) {m_property = std::forward<T>(t);}

which subsumes both the const& and && case, as well as being capable of accepting any type that is assignable to m_property. Be aware that this is hell on readability, and results in "interesting" error messages when misused.

+1 I am always looking for new ways to amaze my friends and family. — Neil Kirk, Jul 29 '13 at 03:11
Excellent answer. I would say however, that the perfect forwarding case (if, and only if, appropriate for the `Property`) isn't much worse on readability than having the *two* overload versions (`const&`and `&&`). And IMHO, you probably want a short comment in both cases, explaining which is which. I'm actually writing this because I feel that, generally, for a property-setting method like outlined, the perfect forwarding signature seems to make a lot of sense. — Martin Ba, Jul 29 '13 at 06:05

score 2 · Accepted Answer · answered Jul 29 '13 at 02:25

2

This one is better

void setProperty(Property const& p)   {m_property = p;}

It saves one copy of Property when enters setProperty function, it only copies a reference to Property which is very cheap.

answered Jul 29 '13 at 02:25

billz

44,644
9
83
100

1

While this is the proper C++03 way, or even the C++11 way if `Property` does not implement move assignment, this is suboptimal in C++11 with a movable type. If the argument to the function is a temporary, this will incur one more copy than needed. – David Rodríguez - dribeas Jul 29 '13 at 03:39

score 1 · Answer 3 · answered Jul 29 '13 at 03:36

The question can only be answered by looking at the Property type. If it implements move operations, then the best approach is to take the argument by value and move it internally:

void setProperty(Property p)   {m_property = std::move(p);}

If the argument is an lvalue, the copy will be done in the interface, and you will move the value internally, and the cost will be one copy and one move (moves should be cheap). If the argument to the function is a temporary, the compiler can elide the copy (and if it doesn't, it must move rather than copy). Then the function will perform another move internally for a total cost of one (or two) move operations, which are cheap.

If you had passed by const&, then in the case where the argument is a temporary, the compiler would not be able to elide the copy and you would pay for two copies.

Regarding the suggestion to use perfect forwarding, if you have access to the interface of the Property type (which you should, since you are holding a member), there is no need to make the setter a template, as that will generate unnecessary extra code in the final executable and unnecessary complexity for other maintainers.

score 0 · Answer 4 · answered Jul 29 '13 at 02:36

When you use a constant reference, you only send a pointer to the function instead of copying the whole Object (class Property). This can save you some time, especially if the Property is big. What is more, it saves you precious memory.

However, you are not allowed to make any changes due to the const&. If you remove the const, any changes will be done to the original Object.

To sum up, if you just want to get information from the Property Object without making any changes, a constant reference (const&) is the best way to go.

score 0 · Answer 5 · answered Jul 29 '13 at 02:44

In general, passing by reference is best because it saves copying the object. If the object is small with trivial copying behavior (has a few ints and default copy constructor) then the cost of copying the object is negligible. In some cases, pass by value may be faster as the optimizer knows nothing else can modify the object the function has received. As I have no idea what Property is, I would pass by reference in case it is a large or complex class. When in doubt, pass by reference.

In C++11 things can be different due to move constructors and stuff but I don't fully understand them. But you won't go far wrong with the this advice. When in doubt, pass by reference!

Which set methods has better performance: with or without `const&`?

5 Answers5