sequence-points

Does standard C++11 guarantee that all 3 temporary objects have been created before the beginning performe the function? Even if temporary object passed as: object rvalue-reference passed only member of temporary object http://ideone.com/EV0hSP #include <iostream> using namespace std; struct T { T() { std::cout << "T created \n"; } int val = 0; ~T() { std::cout << "T destroyed \n"; } }; void function(T t_obj, T &&t, int &&val) { std::cout << "func-start \n"; std::cout << t_obj.val << ", " << t.val << ", " << val << std::endl; std::cout << "func-end \n"; } int main() { function(T(), T(), T()

§5.1.2.4.16 EXAMPLE 7 The grouping of an expression does not completely determine its evaluation. In the following fragment: #include <stdio.h> int sum; char *p; /* ... */ sum = sum * 10 - '0' + (*p++ = getchar()); the expression statement is grouped as if it were written as sum = (((sum * 10) - '0') + ((*(p++)) = (getchar()))); but the actual increment of p can occur at any time between the previous sequence point and the next sequence point (the ; ), and the call to getchar can occur at any point prior to the need of its returned value. So basically I understand this as unspecified behavior

I'm trying to pin down my understanding of sequence points in C -- just wanted to check something. At present, I believe that (1) is undefined whereas (2) is merely unspecified, on the basis that in (2), there are sequence points after evaluating the arguments for g and h (so we're not modifying i twice between sequence points), but the order of evaluation of the arguments of f is still unspecified. Is my understanding correct? #include <stdio.h> int g(int i) { return i; } int h(int i) { return i; } void f(int x, int y) { printf("%i", x + y); } int main() { int i = 23; f(++i, ++i); // (1) f(g(

Is (++i)++ undefined behavior? Is it possible that the side effect of prefix increment happens after retrieving the incremented object for postfix increment to operate on? That would seem strange to me. My gut feeling says this is undefined in C++03 and well-defined in C++11. Am I right? My gut feeling says this is undefined in C++03 and well-defined in C++0x. Yes you are right. The behaviour is undefined in C++03 because you are trying to modify i more than once between two sequence points. The behaviour is well defined in C++0x because (++i)++ is equivalent to (i += 1)++ . The side effects

In another answer it was stated that prior to C++11, where i is an int , then use of the expression: *&++i caused undefined behaviour. Is this true? On the other answer there was a little discussion in comments but it seems unconvincing. It makes little sense to ask whether *&++i in itself has UB. The deferencing doesn't necessarily access the stored value (prior or new) of i , as you can see by using this as an initializer expression for a reference. Only if an rvalue conversion is involved (usage in such context) is there any question to discuss at all. And then, since we can use the value

to describe the problem simply, please have a look at the code below: int main() { int a=123; ({if (a) a=0;}); return 0; } I got this warning from [-Wsequence-point] Line 4: warning: operation on 'a' may be undefined my g++ version is 4.4.5 I'll appreciate whoever would explain this simple problem. btw you could find my original program and original problem in #7 in this Chinese site (not necessary) UPD1: though to change the code into ({if(a) a=0; a;}) can avoid the warning, but I recognized that the real reason of the problem may not be The last thing in the compound statement should be an