This question already has answers here:
double '=' in initialization
(3 answers)
Closed 3 years ago.
My apologies if this is a duplicate: searching for this isn't easy.
Example code taken from rtorrent:
m_bindings[KEY_UP] = m_bindings['P' - '#'] = std::bind(&ElementDownloadList::receive_prev, this);
What does the double value-setting mean, and how can this statement be explained?
The expression is evaluated from the right equals sign to the left. The statement a = b = c can be rewritten a = (b = c). The result of an = operation is the value that was assigned. Thus the result of (b = c) is c, making the next operation equivalent to a = c.
This is similar to x = y = 1 which is short hand for y = 1 and x = y.
This is called operator chaining. What you are doing is assigning the return value of the right hand operator = to the left hand operator =
It is equivalent to doing
m_bindings['P' - '#'] = std::bind(&ElementDownloadList::receive_prev, this);
m_bindings[KEY_UP] = m_bindings['P' - '#'];
but saves you a line of code. It also saves you from calling operator[] a second time, which could be expensive. Personally, I would use the 2 line version to make the code easier to read unless performance is really an issue.
Related
This question already has answers here:
What does =+ (equals-plus) mean in C?
(7 answers)
Closed last year.
I often confuse both "-=" and "=-", like what is the exact difference between them?
int main()
{
int x=10, a=-3;
x=-a;
printf("%d",x);
return 0;
}
Output
3
-= is a compound assignment operator. =- is two operators applied seperately.
While
a =- 3;
is the same as
a = (-3);
This
x -= a;
is more or less equivalent to
x = x - a;
"More or less" because operators can be overloaded (in C++) and typically the compound operator avoids the temporary right hand side.
Btw you are using =- twice in your code while the questions asks for += vs =+. += is a compound operator as well.
This question already has answers here:
Why are these constructs using pre and post-increment undefined behavior?
(14 answers)
Closed 4 years ago.
test321["abc"] = 1;
test321["abc"] = test321.count("abc") ? test321["abc"]++ : 0;
test321["abc"] = 1
test321["abc"] = 1;
test321["abc"] = test321.count("abc") ? test321["abc"]+1 : 0;
test321["abc"] = 2
Why is there a difference?
The line
test321["abc"] = test321.count("abc") ? test321["abc"]++ : 0;
has undefined behavior until C++17 since test321["abc"] is modified in two ways:
By assignment.
By the post increment operator.
It's best to avoid using such constructs. You can read more about it at Why are these constructs (using ++) undefined behavior in C?.
The second approach is well-behaved code and should be used for what you intend to do.
If you use C++17, both approaches should result in identical behavior.
The question you're posing, "Why is there a difference?", is less meaningful than you might expect, because your code invokes Undefined Behavior.
Consider the following code snippet which is, semantically, equivalent to what your code is doing:
int x = 1;
x = x++;
What is a logical result for x? Is there a logical result?
Well, if you ask the C++ standard, the answer is that there is no logical result, and it leaves the result of an operation like this to be undefined. Any given compiler is given no restrictions or limitations on what it should do with code like this, so some compilers will work out that a logical result is for x to equal 2, and some compilers will work out 1 instead. Some compilers might (rarely) do something else entirely.
For more on this particular phenomenon, see this related Question.
To avoid undefined behavior, you should prefer constructs like this:
auto & ref = test321["abc"];//We save the reference to avoid performance issues
//Note that the brackets operator will create an entry if it doesn't already exist, negating
//the need for a check to count(); count() will always return at least 1.
ref = 1;
ref = ref + 1;
Or
if(auto & ref = test321["abc"])
ref++;//Will only increment if value was not 0.
This question already has answers here:
Why does i[arr] work as well as arr[i] in C with larger data types?
(5 answers)
Closed 7 years ago.
The following code
#include<stdio.h>
int main()
{
int arr[] = {10,20,30};
cout << -2[arr];
return 0;
}
prints -30. How? Why?
In your case,
cout<<-2[arr];
gets translated as
cout<<-(arr[2]);
because,
array indexing boils down to pointer arithmatic, so, the position of array name and the index value can be interchanged in notation.
The linked answer is in C, but valid for C++ also.
regarding the explicit ()s, you can check about the operator precedence here.
Look at this statement
cout << -2[arr];
First, know that even though it looks strange the following is true
2[arr] == arr[2]
That being said operator[] has higher precedence than -. So you are actually trying to invoke
-(arr[2])
In C and C++, 2[arr] is actually the same thing as arr[2].
Due to operator precedence, -2[arr] as parsed as -(2[arr]). This means that the entire expression evaluates to negating the 3rd element of arr, i.e. -30.
This question already has answers here:
What does the comma operator , do?
(8 answers)
Closed 8 years ago.
I have done some searching, but didn't find the answer
The code:
char b = 'b';
char c = 'c';
char a[5] = "";
a[0] = b, c;
What last line means? The b, c part?
Thank you all
That uses the elusive comma operator to cause confusion.
It evaluates b, and result of that is then asssigned to a[0]. After that, c is evaluated but its value thrown away. At least this is the case in C.
The comma has lower precedence than assignment (see this handy table) which is extra confusing.
This question already has answers here:
Undefined behavior and sequence points
(5 answers)
Closed 9 years ago.
Example code
int arr[3] = { 0, 1 };
int* buf = arr;
*buf++ = *buf + 10;
Result of last expression is that buf[0] == 10. I taught it would be buf[0] == 11.
A college of mine wrote something similar to the example code and I taught it works differently than it does. And I would like to know why it works the way it does.
The way I went about figuring it out was to look at the operator precedence table. There it states that suffix ++ has precedence over dereference. Hence I taught that on the left of operator= buf would point to the first element, but on the right of the operator= it would have already been incremented and would point to the second element. However that is not the case.
My question is, why is that so? Preferably a standard quote :) However any explanation is welcome!
You are accessing and modifying the pointer multiple times in a single sequence point. This is undefined behavior.
More generally, reading from and writing to any variable between sequence points is undefined. The fact that you have a pointer in this specific example is by-the-by.
To avoid confusion with the pointer:
int i = 0;
i++ = i + 1; // UB
Logically, should the i on the right hand side be the "current" value of i, or the modified value? This is why it is undefined. Instead, separate the code:
int i = 0;
++i;
i = i + 1;
Which is clear, and well defined.