operator-precedence

Following is the test code: int main() { int a = 3; int b = 4; a = a + b - (b = a); cout << "a :" << a << " " << "b :" << b << "\n"; return 0; } Compiling this gives the following warning: > $ g++ -Wall -o test test.cpp test.cpp: In function ‘int main()’: > test.cpp:11:21: warning: operation on ‘b’ may be undefined > [-Wsequence-point] Why can the operation be undefined? According to my understanding, first the subexpression (b = a) should be evaluated because of higher precedence of (), thus setting b = a. Then, since '+' and '-' have same precedence, the expression would be evaluated left

What is the order of evaluation in the following query: UPDATE tbl SET q = q + 1, p = q; That is, will "tbl"."p" be set to q or q + 1 ? Is order of evaluation here governed by SQL standard? Thanks. UPDATE After considering Migs' answer , I ran some tests on all DBs I could find. While I don't know what the standard says, implementations vary. Given CREATE TABLE tbl (p INT NOT NULL, q INT NOT NULL); INSERT INTO tbl VALUES (1, 5); -- p := 1, q := 5 UPDATE tbl SET q = q + 1, p = q; I found the values of "p" and "q" were: database p q -----------------+---+--- Firebird 2.1.3 | 6 | 6 -- But see

If I want to select a subset of data in R, I can use the subset function. I wanted to base an analysis on data that that was matching one of a few criteria, e.g. that a certain variable was either 1, 2 or 3. I tried myNewDataFrame <- subset(bigfive, subset = (bigfive$bf11==(1||2||3))) It did always just select values that matched the first of the criteria, here 1. My assumption was that it would start with 1 and if it does evaluate to "false" it would go on to 2 and than to 3, and if none matches the statement after == is "false" and if one of them matches, it is "true". I got the right result

We get into unnecessary coding arguments at my work all-the-time. Today I asked if conditional AND (&&) or OR (||) had higher precedence. One of my coworkers insisted that they had the same precedence, I had doubts, so I looked it up. According to MSDN AND (&&) has higher precedence than OR (||). But, can you prove it to a skeptical coworker? http://msdn.microsoft.com/en-us/library/aa691323(VS.71).aspx bool result = false || true && false; // --> false // is the same result as bool result = (false || true) && false; // --> false // even though I know that the first statement is evaluated as

map<int, int> mp; printf("%d ", mp.size()); mp[10]=mp.size(); printf("%d\n", mp[10]); This code yields an answer that is not very intuitive: 0 1 I understand why it happens - the left side of the assignment returns reference to mp[10] 's underlying value and at the same time creates aforementioned value, and only then is the right side evaluated, using the newly computed size() of the map. Is this behaviour stated anywhere in C++ standard? Or is the order of evaluation undefined? Result was obtained using g++ 5.2.1. Yes, this is covered by the standard and it is unspecified behavior. This

So, I'm looking into writing a slightly more complex operation with logic operators in an if-else statement. I know I can do parentheses, and I know it's the better way of doing this, but I've gotten curious and so I'm going to ask. If I were to do something like this: if (firstRun == true || selectedCategory != undefined && selectedState != undefined) { //Do something } else { //Do something else } How will that be operated without the use of parentheses? I know there is an order of operations for logic operators, similar to PEMDAS, right? I'm curious if it'll be ran something like this:

Is order of execution in constructor initialization list determinable? I know that members order in a class is the order in which those members will be initialized but if I have scenario like this: class X() { X_Implementation* impl_; }; and then providing that allocator is available: X::X():impl_(Allocate(sizeof(X_Implementation)))//HERE I'M ALLOCATING <--1 ,impl_(Construct<X_Implementation>(impl_))//AND HERE I'M CONSTRUCTING <--2 { } but in order for this to be dependable this order MUST be from left to right. Is it guarantied by GREAT BOOK OF std:: or not? If not I can always move the

I have a single line code, int a = 10; a = ++a * ( ++a + 5); My expected output was 12 * (11 + 5) = 192 ,but I got 187 . As much as I knew the increment operator inside () is to be solved first, then why the one outside is solved first? Expressions are evaluated left to right. Parentheses (and precedence) just express grouping, they don't express ordering of evaluation. So 11 * (12 + 5) ++a ++a equals 187 Quoting from Eric Lippert's Blog : The evaluation of an arithmetical expression is controlled by three sets of rules: precedence rules, associativity rules, and order rules. Precedence rules

Let's take a simple example of an object Cat . I want to be sure the "not null" cat is either orange or grey. if(cat != null && cat.getColor() == "orange" || cat.getColor() == "grey") { //do stuff } I believe AND comes first, then the OR. I'm kinda fuzzy though, so here are my questions: Can someone walk me through this statement so I'm sure I get what happens? Also, what happens if I add parentheses; does that change the order of operations? Will my order of operations change from language to language? The Java Tutorials has a list illustrating operator precedence . The equality operators