sequence-points

This is yet another sequence-point question, but a rather simple one: #include <stdio.h> void f(int p, int) { printf("p: %d\n", p); } int g(int* p) { *p = 42; return 0; } int main() { int p = 0; f(p, g(&p)); return 0; } Is this undefined behaviour? Or does the call to g(&p) act as a sequence point? No. It doesn't invoke undefined behavior. It is just unspecified , as the order in which the function arguments are evaluated is unspecified in the Standard. So the output could be 0 or 42 depending on the evaluation order decided by your compiler. The behavior of the program is unspecified since we

So I've seen a lot of articles now claiming that on C++ double checked locking, commonly used to prevent multiple threads from trying to initialize a lazily created singleton, is broken. Normal double checked locking code reads like this: class singleton { private: singleton(); // private constructor so users must call instance() static boost::mutex _init_mutex; public: static singleton & instance() { static singleton* instance; if(!instance) { boost::mutex::scoped_lock lock(_init_mutex); if(!instance) instance = new singleton; } return *instance; } }; The problem apparently is the line

I read here that there is a sequence point: After the action associated with input/output conversion format specifier. For example, in the expression printf("foo %n %d", &a, 42) , there is a sequence point after the %n is evaluated before printing 42 . However, when I run this code : int your_function(int a, int b) { return a - b; } int main(void) { int i = 10; printf("%d - %d - %d\n", i, your_function(++i, ++i), i); } Instead of what I expect I get: 12 - 0 - 12 Meaning that there was not a sequence point created for the conversion format specifier. Is http://en.wikipedia.org wrong, or have I

In C/C++, the second statement in int i = 0; int j = i++ + i++ + ++i; invokes both unspecified behavior , because the order of evaluation of operands is unspecified, and undefined behavior , because the side effects on the same object i are unsequenced relative to each other. See for example Why are these constructs (using ++) undefined behavior? Undefined behavior and sequence points Now, given that Swift was designed as a safe language, what is the corresponding situation here? Is the result of var i = 0 let j = i++ + i++ + ++i well-defined? Can one conclude from the language reference in

C99 §6.5 Expressions (1) An expression is a sequence of operators and operands that specifies computation of a value, or that designates an object or a function, or that generates side effects, or that performs a combination thereof. (2) Between the previous and next sequence point an object shall have its stored value modified at most once by the evaluation of an expression. 72) Furthermore, the prior value shall be read only to determine the value to be stored. 73) with the footnotes 72) A floating-point status flag is not an object and can be set more than once within an expression. 73)