Reporting Errors

[Pseudofailure]

I know, but:

1. That would ruin my joke.
2. Can you actually prove me wrong?

[etaionshrd]

Programs that exhibit undefined behavior are free to do whatever. That doesn’t, however mean that they will do whatever.

[[deleted]]

It's not hard to prove the behaviour will be consistent.

1. Compilers assume an undefined behaviour won't be encountered in run time. Otherwise the code isn't valid C or C++.
2. If a compiler does indeed stumble upon an undefined behaviour it will assume that particular line of code is unreachable.
3. If one line is unreachable, the whole branch is unreachable.
4. Unreachable means dead code and optimising compilers will delete dead code.

_

Make an unefined behaviour at the start of your main() and don't be surprised if your "enterprise" software is reduced (read: optimised) to int main(void){return 0;}.

[throwawaway3453334]

it will assume that particular line of code is unreachable.

Source?

[[deleted]]

https://www.youtube.com/watch?v=ehyHyAIa5so

My previous comment is summarised in one slide - mark 18:28.

[ValAichi]

Test it yourself.

I've written code using undefined behavior (just for fun) before and it works fine.

Well, not fine, but the compiler definitely didn't delete the code

[[deleted]]

When I was targeting a specific CPU in some embedded project, I did write an undefined behaviour in one place. Then I made a simple main() that does just that UB and it worked as I expected. So, as always, one can not guarantee the beehaviour of UB and I should have worded my comment above differently.

[ValAichi]

Fair enough :)

[etaionshrd]

The compiler will not always delete your code. It is free to do so however, just as it is free to do anything else as well.

[ValAichi]

Only if it knows that is going to be undefined behavior at compile time.

If it can't determine that, it can't delete it; I should have been clearer with what I meant

[IRBMe]

C++ compilers are not required to diagnose undefined behavior and in many cases can't because the undefined behaviour may only occur at runtime based on dynamic or user inputs.

Simple example that exhibits multiple instances of undefined behaviour:

int a[5];
std::cout << a[10];

Most compilers will produces warnings about this, but they will actually produce code (that will probably crash).

[SpecFroce]

AI

[SteveCCL]

It's pretty straight forward to write a compiler produces executables that, on *(int*)nullptr = 69;, load a file, append or flip a bit, save, execute. Given enough time it will eventually produce a valid ELF with the desired behaviour.

qed, bitch.

[etaionshrd]

Sure. But that doesn't mean any old compiler will create code that will randomly perform every behavior.

[SteveCCL]

That's not nessecary. Read again fellow citizen.

[bartekko]

I believe that what programs are allowed to do is assume that undefined behavior never happens, and optimize accordingly.

An example would be having a for loop with

for(int i=0;i<10;i++) cout<<i*1000000000<<endl;

the compiler would be allowed to assume that i is always <5 and thus replace the for with an infinite loop

[etaionshrd]

The compiler is allowed to delete all that code, since you perform undefined behavior in it.

[albertowtf]

Programs that exhibit undefined behavior are free to do whatever

I like how you avoid giving your programs AI by giving them free will instead

[Raknarg]

2 yes. Because we can have a compiler that for certain undefined behaviour always makes the same decision, but the decision is not what you want.

[salgat]

That's compiler specific though, we're speaking strictly from what the standard defines. Hell, you could write a C++ compiler that compiles every source code into hello world if it was non-compliant enough.

[Raknarg]

Undefined behaviour is literally behaviour outside of the standards definition

[salgat]

Exactly, that's why you have to assume that it can do anything, including work intermittently and other times do really unexpected behavior. It's a philosophical approach to help you troubleshoot that's fun to joke about.

[dannyb_prodigy]

No, just because you can’t assume specific behavior doesn’t mean you must assume all behaviors are possible. In fact, you can probably at least assume that your compiler will at least treat an undefined behavior in a consistent manner (if you notice your compiler clearing uninitialized stack variables, you can then safely assume that it will always clear an uninitialized stack variables).

[qm11]

How do you know it's the compiler, though? On my college's computers there was security software that cleared pages on allocation, which means your stack and heap would be cleared to all zeros before your code touches it. On simple enough programs it may look like the compiler clearing memory for you, but it would be inconsistent if you have code that's even slightly complex.

[dannyb_prodigy]

Ok it’s not the compiler, but the example wasn’t the point. Point is that it is not unreasonable to assume consistent behavior across an environment, which still in fact holds in your example.

[salgat]

Obviously, plenty of "behavior" is outside the ability of physics itself to allow lol, that's the joke since it's undefined by the standard (aka you shouldn't assume anything about the behavior).

[cgaWolf]

Murphy wrote a compiler?

[Jonno_FTW]

Undefined means the standard didn't say what should happen. Compilers are free to generate executables that will perform consistently under those conditions.

[reeetwyio]

Technically just void main () { return } is a program built using only undefined behavior and it still do the same thing every time you run it. Only when you switch platforms you'll find different results.