Check current value before assignment in set method - c++

Question

I'll start from a code snipped of an application I found over the internet. It's made in C++ but the topic could be addressed to any programming language:
class AppSettings
{
public:
AppSettings() {m_value = 0;}
~AppSettings();
void AppSettings::setValue(uint value)
{
if (m_value != value)
m_value = value;
}
private:
uint m_value;
};
Do you really need to check that the current value differs from the new one before assignment?
Is it just a programming style, efficiency, good manner, or what?
General speaking, in set method of a class, do you need to check that new value differs from current one?

Answer 1

This largely depends on the type of the member being assigned. If it's a primitive type or something equally lightweight, the check is most likely a pessimisation: the assignment is likely to be significantly cheaper than the conditional jump. Remember that basically all modern processors are pipeline-based, and conditional jumps can result in the pipeline needing to be aborted if branch prediction fails. This kills efficiency.
If the type is much more costly to assign, the answer is not so clear-cut. Copying a large buffer of data, for example, is an expensive operation. However, so is comparing it for equality. To make the call on whether to assign blindly or compare first, you need to understand the idiosynracies of the type in question, and evaluate how often same-value assignments are likely to happen, how quick they are to identify, and how costly this identification is compared to copying "blindly." Also bear in mind that if the comparison indicates they the values are different, you will have paid for both: the comparison, and then the copy.
Finally, there are cases when the check is necessary: when the assignment has a side effect. For example, if the type of the member is such that it emits a notification whenever assigned to, you will most likely need the comparison to avoid spurious notifications (assuming you don't want those, of course).
In all, there is no hard-and-fast rule, but I would say that on average, you should only include the comparison if you have good reason for it.

Answer 2

Do you really need to check that the current value differs from the new one before assignment? Is it just a programming style, efficiency, good manner, or what?
It looks like cruft to me.
You usually end up with code like this, when you mix two ideas while writing the code ("We only update state when necessary" vs. "the setter just sets the value"), and the sample code ends up not expressing either idea clearly.
I cannot say though - I would have to read the article you took the code from.
General speaking, in set method of a class, do you need to check that new value differs from current one?
You do, when you either optimize, or when the idea you need to express in code is "perform updates when necessary".
Consider this (artificial and contrieved) code:
/// object in 2D space
class TwoDObject
{
/// shift object position
void shift_position(int x, int y)
{
if(x != x_ || y != y_)
{
x_ = x;
y_ = y;
render_shadows();
}
}
private:
// render the shadows cast by this object (slow implementation)
void render_shadows();
int x_;
int y_;
};
In this case, you have an internal state update, followed by side effects (shadows have changed when you changed position).
Because the method to render the shadows is slow, you only want to call it when necessary.

Answer 3

It really depends on what you are setting, what I mean, It is important to do it if you are setting things that will propagate changes. If the cost of that change is quite big(reorder an entire array, update data in some network place, rewrite a big file) in this cases, and if the program needs real time performance, it is a good practice to check unnecesary changes. If the change has no side-effects is better just change it and avoid extra branching.