The code in the post seems very similar to the one in my own post from 2010: <a href="https://susam.net/sequence-points.html" rel="nofollow">https://susam.net/sequence-points.html</a><p><pre><code> int a = 5;
a += a++ + a++;
</code></pre>
I do remember that this particular code snippet (with a = 5, even) used to be popular as an interview question. I found such questions quite annoying because most interviewers who posed them seemed to believe that whatever output they saw with their compiler version was the correct answer. If you tried explaining that the code has undefined behaviour, the reactions generally ranged from mild disagreement to serious confusion. Most of them neither cared about nor understood 'undefined behaviour' or 'sequence points'.<p>I remember one particular interviewer who, after I explained that this was undefined behaviour and why, listened patiently to me and then explained to me that the correct answer was 17, because the two post-increments leave the variable as 6, so adding 6 twice to the original 5 gives 17.<p>I am very glad these types of interview questions have become less prevalent these days. They have, right? Right?
IMO, The only reasonable answer if asked this in an interview is “I would not write code where I have to know the answer to this question”<p>These sorts of things are neat trivia to learn about things like sequence points but 99.9% of the time if it matters in your codebase you're writing something unmaintainable.
> IMO, The only reasonable answer if asked this in an interview is “I would not write code where I have to know the answer to this question”<p>That's half of a reasonable answer. The other half is "but I do know the answer so if I see it when reviewing or working on someone else's code I can flag it or rewrite it, and explain to them why it is bad".
In some sense, and without the interviewer knowing, that is actually a great scenario for an interview.<p>If you can convince someone in a position of authority that they’re wrong about something technical without upsetting them then you’re probably a good culture fit and someone who can raise the average effectiveness of your team.
Or, also, in the reverse direction, if the interviewer is wrong about it and can't be convinced otherwise, it's probably not a great place to work.
I know I did recommend someone after the interview because I looked it up and they were right. Great person to work with. Though I fully understand why most would hesitate.
The best interview questions spawn discussions. This is a pretty good one for that. We could dive into what makes it UB, why a particular compiler might do it a certain way, what results we'd likely see from other compilers, and why the standard might say that this sort of thing is UB.<p>"What does this produce?" and expecting an answer of "17" is a bad question even if UB didn't mean the expected answer is wrong.
> I found such questions quite annoying because most interviewers who posed them seemed to believe that whatever output they saw with their compiler version was the correct answer.<p>Other than the job for most programmers having nothing to do with whether they know the outcome, because hopefully they'd never write something like it or clean it up. And IF they found it they'd hopefully test it - given that it appears to be compiler dependent anyways.
Do you want a job at a place where someone who doesn't understand UB makes the hiring decisions?
I think your options are very limited if you look for places that have people that truly understand UB, even less so the hiring people.
Sometimes, even in tech, you just need a job.
How many tennis balls can fit in a bus?
Heh, one time when I got this style of question[1] (but for JavaScript), I took a glance at it and said "Um ... you really shouldn't write code like that." The interviewer replied, "Oh. Yeah. Fair point." And then went on to another question.<p>[1] By which I mean predicting the behavior of error-prone code that requires good knowledge of all the quirks of the language to correctly answer.
>I am very glad these types of interview questions have become less prevalent these days. They have, right? Right?<p>I just refuse to do interviews like that any more.
What's the reason that C didn't define the order of this?<p>The horrible undefined behavior of signed integer overflow at least can be explained by the fact that multiple CPU architectures handling those differently existed (though the fact that C even 'attracts' its ill-defined signed integers when you're using unsigned ones by returning a signed int when left shifting an uint16_t by an uint16_t for example is not as forgivable imho)<p>But this here is something that could be completely defined at the language level, there's nothing CPU dependent here, they could have simply stated in the language specification that e.g. the order of execution of statements is from left to right (and/or other rules like post increment happens after the full statement is finished for example, my point is not whether the rule I type here is complete enough or not but that the language designers could have made it completely defined).
The short answer is because C was designed to give leeway to really dumb compilers on really diverse hardware.<p>This isn't quite the same case, but it's a good illustration of the effect: on gcc, if you have an expression f(a(), b()), the order that a and b get evaluated is [1] dependent on the architecture and calling-convention of f. If the calling convention wants you to push arguments from right to left, then b is evaluated first; otherwise, a is evaluated first. If you evaluate arguments in the right order, then after calling the function, you can immediately push the argument on the stack; in the wrong order, the result is now a live variable that needs to be carried over another function call, which is a couple more instructions. I don't have a specific example for increment/decrement instructions, but considering extremely register-poor machines and hardware instruction support for increment/decrement addressing modes, it's not hard to imagine that there are similar cases where forcing the compiler to insert the increment at the 'wrong' point is similarly expensive.<p>Now, with modern compilers using cross-architecture IRs as their main avenue of optimization, the benefit from this kind of flexibility is very limited, especially since the penalties on modern architectures for the 'wrong' order of things can be reduced to nothing with a bit more cleverness. But compiler developers tend to be loath to change observable behavior, and the standards committee unwilling to mandate that compiler developers have to modify their code, so the fact that some compilers have chosen to implement it in different manners means it's going to remain that way essentially forever. If you were making a new language from scratch, you could easily mandate a particular order of evaluation, and I imagine that every new language in the past several decades has in fact done that.<p>[1] Or at least was 20 years ago, when I was asked to look into this. GCC may have changed since then.
I'd say it's more like C was designed <i>from</i> really dumb compilers on really diverse hardware. The standard, at least the early versions of it, was more to codify what was out there than to declare what was correct. For most things like this in the standard, you can point to two pre-standardization compilers that did it differently.
Sethi-Ullman register allocation reorders subexpression evaluation to achieve efficient register allocation: <a href="https://dl.acm.org/doi/10.1145/321607.321620" rel="nofollow">https://dl.acm.org/doi/10.1145/321607.321620</a><p>With modern register allocators and larger register sets, code generation impact from following source evaluation is of course lower than it used to be. Some CPUs can even involve stack slots in register renaming: <a href="https://www.agner.org/forum/viewtopic.php?t=41" rel="nofollow">https://www.agner.org/forum/viewtopic.php?t=41</a><p>On the other hand, even modern Scheme leaves evaluation order undefined. It's not just a C issue.
Applying the increment or decrement operators over the same variable more than once on the same line should be a compile-time error.<p>Anyway, yes, this one example has an obvious order it should be applied. But still, something like it shouldn't be allowed.
> Applying the increment or decrement operators over the same variable more than once on the same line should be a compile-time error<p>That would be nice, but don't forget the more general case of pointers and aliasing:<p><pre><code> int a = 5;
int *pa = &a;
printf("%d", (a++ + ++*pa));
</code></pre>
The compiler cannot statically catch every possible instance of a statement where a variable is updated more than once.
Honestly, having increment in expressions rather than a statement feels like more of a footgun than a benefit. Expressions shouldn't mutate things.
I think the history of this is that these operations were common with assembly programmers, so when C came along, these were included in the language to allow these developers to feel they weren't leaving lots of performance behind.<p>Look at the addressing modes for the PDP-11 in <a href="https://en.wikipedia.org/wiki/PDP-11_architecture" rel="nofollow">https://en.wikipedia.org/wiki/PDP-11_architecture</a> and you'll see you can write (R0)+ to read the contents of the location pointed to by R0, and then increment R0 afterwards (so a post increment).<p>Back in the day, compilers were simple and optimisations weren't that common, so folding two statements into one and working out that there were no dependencies would have been tough with single pass compilers.<p>You could argue that without such instructions, C wouldn't have been embraced quite so enthusiastically for systems programming, and the world would have looked rather different.
Python recently went the other way and added an assignment expression. I actually wish more languages would go further and add statement expressions instead of having to imitate them with IIFEs.<p>C just wouldn't be C without things like a[i++]
Those things are for pointer golf and writing your entire logic inside the if statement.<p>Both are favorite idioms of C developers. And they are ok if done correctly, clearer than the alternative. They are also unnecessary in modern languages, so those shouldn't copy it (yeah, Python specifically).
In any language where the practice of iteration isn't achieved via C-style for-loops, having an operator devoted to increment just doesn't make sense (let alone <i>four</i> operators, for each of pre/post-increment/decrement). This is one of those backwards things that just needs to be chucked in the bin for any language developed post-2010.
Wenn wouldn't have pearls like while (<i>dst++ = </i>src++);
It's valuable for compilers to be able to choose the instruction scheduling order. Standards authors try not to unnecessarily bind implementors. If post increment happened after the full statement is finished, then the original value has to be maintained until the next sequence point. Maybe the compiler will be smart enough to elide that, maybe not, but it's a lot more difficult to fix those kinds of edge cases than to say sequencing is undefined.
But this is not valuable if doing so results in different numerical results, and I think that will always happen if ++ is executed at different times, there's no point in a compiler optimizing pointless code that can silently give different results elsewhere
Your compiler does many optimizations that break numerical reproducibility, especially in floats. I reviewed a PR the other day that wrote
X=A<i>B+(C</i>D)+E;<p>And when I checked 3 different compilers, each of them chose a different way to use FMAs.<p>Even with integer math, you can get different numerical results via UB (e.g. expressions with signed overflow one way and not another).
It would only make a difference in cases that are currently UB, so there is no program valid under current C that would be pessimized by this change.
It's a language feature that was in K&R, and the rules around sequencing were introduced in C89. There were good reasons to believe it would pessimize code in the following decades. Dennis Richie himself pointed out that Thompson probably added the operators because compilers of the time were able to generate better code that way.
The C standard doesn't define things where two or more historical compilers disagreed and there wasn't an obviously correct way. This is defined behavior (left to right, assignment last) in Java, which is a different language.
Probably because when C was standardised there were already multiple implementations, and this was an area where implementations differed but it wasn't viewed as important enough to bring them in line with one approach.
The only other reasonable option is to make such garbage a compile time error. There is no reasonable definition of what code like that should do and if you write it in the real world you need find better job fit. I'd normally say McDonald's is hiring, but they don't want people like that either
> What's the reason that C didn't define the order of this?<p>I didn't open TFA but my first thought was <i>"Is this even defined?"</i>.<p>It kinda make sense that suck fucktardedness could be not defined.
The statement is valid C#, which has left-to-right execution order and no undefined behavior. The answer is 5 + 7 = 12.
I had to fight through school and university in India with my teachers who believed these were legit questions to ask in written exams. Can't 100% blame them since almost all standard-issue textbooks had them and claimed they'd give predictable output. I thought the same until I noticed the weirdness when running them across different compilers and after I read about UB, sequence points and similar quirks in books that are not total garbage.<p>Luckily, I ended up with smug smiles in all those cases after showing them the output from different compilers.
> The interesting thing here is the Undefined Behavior (UB), well... actually two UBs, thanks to which there are three possible correct answers: 11, 12 and 13.<p>No, if you invoke undefined behavior any result at all is possible.
Hey! Author here :)<p>So let me start by saying that that blog post was written was 15 years ago and I don't even remember the details of it and what I've written there. But, I have a hot-take on this topic you've touched on!<p>From a programmer perspective, you are absolutely right. The behaviour is undefined, end of discussion. A programmer should never rely on what they observe as the effective behaviour of an UB. A programmer must avoid creating situations in code that could result in the execution flow venturing into the areas of UB. And - per C and C++ standards - results of UB can be anything (insert the old joke about UB formatting one's disk being a formally correct behaviour).<p>However, I'm a security researcher, and from the security point of view - especially on the offensive side - we need to know and understand the effective behaviours of UBs. This is because basically all "low-level" vulnerabilities in C/C++ are formally effects of UBs. As such, for the security crowd, it still makes sense to investigate, understand, and discuss the actual observed effects of UBs, especially why a compiler does this, what are the real-world actual variants of generated code (if any) for a given UB for this and other compilers, how can this be abused and exploited, and so on.<p>My point being - there are two sides to this coin.
I feel we need another category - <i>unspecified</i> behavior. I think everyone would agree the compiler should putout ONE of those answers and that nasal demons would be out of spec.<p>The problem is that it’s not specified which should be picked, but all pick something.
I agree what you say seems reasonable at a glance. But (IIUC) the issue is that for optimization we want the compiler to assume that UB doesn't happen in order to constrain the possible code paths. So if it goes some distance down a possible execution branch and discovers UB it can trim the subtree. At that point "anything can happen" becomes an (approximate) reality.<p>The obvious counterpoint in this particular instance is that there's no good reason not to make such an awful expression a compile time error.<p>I also personally think that evaluation order should be strictly defined. I'm unclear if the current arrangement ever offers noticable benefits but it is abundantly clear that it makes the language more difficult to reason about.
The C and C++ standards include "Implementation defined behavior", which means that a conforming implementation can do whatever it wants, as long as it specifically documents and sticks to that behavior.<p>This doesn't really help portability all that much.
With undefined behavior, a conforming compiler can do anything it wants at all, including generating a program that segfaults or something else.<p>But what often happens in practice is that "Bill's Fly-By-Night-C-Compiler-originally-written-in-the-mid-nineties" implemented it in some specific way (probably by accident) and maintains it as a (probably informal) extension. And almost certainly has users who depend on it, and can't migrate for a myriad of reasons. Anyway, it's hard to sell an upgrade when users can't just drop the new compiler in and go.<p>At the language level, it is undefined-behavior, and any code that relies on it is buggy at the language level, and non-portable.<p>Defining it would make those compiler non-conforming, instead of just dependent on defining something that is undefined.<p>Probably the best way forward is to make this an error, instead of defining it in some way. That way you don't get silent changes in behavior.<p>Undefined behavior allows that to happen at the language level, but good implementations at least try not to break user code without warning.<p>Modern compilers with things like UBSan and such makes changing the result of undefined behavior much less of an issue. But most UB is also, "No diagnostic required", so users don't even know they have in their code without the modern tools.
> The interesting thing here is the Undefined Behavior (UB), well... actually two UBs, thanks to which there are three possible correct answers: 11, 12 and 13.<p>There’s UB, so any answer is possible, isn’t it?
Hey! Author here :)<p>I'm going top-to-bottom through comments, and there was a similar question, so I'll link my answer here: <a href="https://news.ycombinator.com/item?id=48140821">https://news.ycombinator.com/item?id=48140821</a> (TL;DR: you are right, but there's another perspective on this)
On my CS lectures algorithms professor used this pseudo language when writing an algorithm on a whiteboard :<p><pre><code> I <- I++
</code></pre>
On the next hour another professor was giving lecture on C++ programming. I asked him the question: what would happen if we compiled<p><pre><code> i = i++
</code></pre>
He went into some deep elaboration on it, but reassumed that only idiot would write like this...
/sarcastic<p>This is how to keep simpletons out of your code base. Every numeric constant is defined in terms of a different lang quiz. Works well in JS as well of course.<p><pre><code> const DEFAULT_SELECTION = true + true
const BASE_PRICE = 4 * parseInt(0.0000001)
const BILLING_DAY_OF_MONTH = a++ + ++a</code></pre>
The final value of a is that if you write this you are fired. It's worse than a racist joke.
The only point you can conclude out of these discussions, especially in an interview, that it doesn't matter what the answer happens to be on $CC and $ARCH but you wouldn't want anyone to write stuff like that in the first place.<p>Failing to recognize the dangers would be an instant fail; knowing that something reeks of undefined behaviour, or even potential UB, is enough: you just write out explicitly what you want and skip the mind games.
I have always hated this crap; the fact that I'm not 100% sure the result of this indicates that maybe the ++ operator (pre or postfix) is something that should be avoided?<p>I don't do a lot of C anymore, but even when I did, I always would do increments on separate lines, and I would do a +=1, or just a = a + 1. I never noticed a performance degradation, and I also don't think my code was harder to read. In fact I think it was easier since I think the semantics were less ambiguous.
Perhaps I'm just naive and/or have forgotten too much C, not that I knew that much, but I'm a bit perplexed as to why this is UB.<p>It seems like something that should trigger a "we should specify this" reaction when adding these operators, and there is at least one reasonable way to define it which is fairly trivial and easily implementable.
I am, thankfully, out of this craziness now but it was fun solving ton of such puzzles from Yashavant Kanetkar books while preparing for campus hiring interviews back in 2000. "Test Your C Skills" in particular. Fun times.<p><a href="https://www.scribd.com/document/235004757/Test-Your-C-Skills-Yashwant-Kanetkar-OCRd" rel="nofollow">https://www.scribd.com/document/235004757/Test-Your-C-Skills...</a>
I love such puzzles! I used to use a lot ternary operators in C++ but one day friend of mine told me that I shouldn't nest ternary operators too much because code is too complicated to read - he understands code perfectly, he was just worried about younger programmers. Since then I started to use longer versions of code instead of smart shortcuts - to improve readability of code.
++ should be banned, just like goto
Some C++ quiz with ++a and a++? It‘s always about sequence points, or better the lack of sequence points.<p>It‘s the standard technical C++ blog post everybody seems to write.
The a=13 was most surprising to me but in retrospect obvious and amusing.
The smart nerd will know precisely how to decode that line's results.<p>The wise nerd will not allow lines like it in their codebase, in the first place and, having seen one, will refactor it (probably involving more lines or parentheses) to make it more clear and easier to maintain.<p>The latter approach scales better, in long run.
> If you would like to test your compiler (posting back the results in the comments is really appreciated, especially from strange/uncommon compilers and other languages which support pre- / post- increment ....<p>Uh, 85% of them show the wrong result so 85% of them clearly do not support pre and post increment.
hmm surprising. I assumed it would be 12 since 5+5+1+1 doesn't really matter what order you do it in. But I suppose this really undefined behavior.
Tried it on <a href="https://www.onlinegdb.com/online_c_compiler" rel="nofollow">https://www.onlinegdb.com/online_c_compiler</a> Returns 12. If I were designing C, it would return 13. But then again, I'm an assembly programmer.
Godbolt: clang and gcc compilers give 12. msvc compilers yield 13.<p><pre><code> #include <stdio.h>
int main() {
int a = 5;
a = a++ + ++a;
printf("%d\n", a);
return 0;
}
</code></pre>
x64 msvc v19.50 VS18.2 output:<p><pre><code> example.c
ASM generation compiler returned: 0
example.c
Execution build compiler returned: 0
Program returned: 0
13
</code></pre>
x86-64 gcc 16.1 output:<p><pre><code> ASM generation compiler returned: 0
Execution build compiler returned: 0
Program returned: 0
12
</code></pre>
armv8-a clang 22.1.0 output:<p><pre><code> <source>:5:10: warning: multiple unsequenced modifications to 'a' [-Wunsequenced]
5 | a = a++ + ++a;
| ^ ~~
1 warning generated.
ASM generation compiler returned: 0
<source>:5:10: warning: multiple unsequenced modifications to 'a' [-Wunsequenced]
5 | a = a++ + ++a;
| ^ ~~
1 warning generated.
Execution build compiler returned: 0
Program returned: 0
12</code></pre>
Please tell me the answer is somehow 42!<p>int a = 5;
a = (++a * a++) + --a; a = ?
Oh god. How long before yet another UB-based question ends up in technical coding interviews?
12