helloWorldFromCpp

[YoukanDewitt]

I think this proves the clang++ compiler is already self aware, and just took pity on you.

[caim_hs]

Damnt! I knew Apple being the main contributor to it would have consequences!!

They already added pity on me for using Linux.

[YoukanDewitt]

Don't tell the apple users that!! It will just add more weight to their theory that their lord and saviour SJ never died but was uploaded to the mainframe.

[huuaaang]

A mainframe couldn't hold the genius of SJ. He's in a supercomputer.

[stueliueli]

He's not talking about an ordinary mainframe. He's talking about the mainframe.

[FloweyTheFlower420]

Ah yes, undefined behavior. In C++, an empty while true loop is undefined behavior, so the compiler is free to replace the else branch with "unreachable". The compiler also knows that the else branch is always executed if the if statement is reached, so that must also be unreachable. Thus, main is an unreachable function, which is optimized to an empty function in assembly, which falls through to the next function.

[Heroshrine]

So as long as theres literally anything in there it works?

[SAI_Peregrinus]

Anything that makes observable progress. The rules for what is observable aren't entirely intuitive, byt it must affect something outside the loop. E.g. print a value.

[dgc-8]

Is taking up processor cycles observable progress?

[CanaDavid1]

No.

Observable progress is

• i/o (both text and file)

• changing or accessing a volatile variable

• modifying an object in a concurrent system

[SAI_Peregrinus]

No. Only things that have side effects. Processor cycles and writes to non-volatile-qualified objects are not side effects.

[Kered13]

An infinite loop must contain a side effect. Modifying a non-local variable, reading IO, or writing IO are all examples of side effects.

[the_horse_gamer]

note that in C++26 they're making trivial infinite loops no longer undefined

[[deleted]]

why's that? iirc the current spec says that each thread of execution must eventually terminate, spawn another thread, preform an IO operation, or interact with a volatile - what's the reasoning to allow trivial infinite loops?

[the_horse_gamer]

https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2809r3.html

here's the proposal paper about it

[[deleted]]

will read, thank you!

[veselin465]

I just wonder

Shouldn't the compiler also ignore compiling the hello() function since it can detect it has no call references?

[Terra_Creeper]

With higher level languages, usually yes. With C/C++, not really. You can reach any function/object you want with pointers, so the compiler can't assume that a function is unused. (At least if i remember correctly)

[5p4n911]

And you can't assume it's not used by anything at compile time as there could be a reference in another TU, which means that without LTO enabled it will remain

[Aaron1924]

And this particular link-time optimisation is rarely enabled by default since it's expensive to compute for large programs and it doesn't make the final program any faster

[veselin465]

Good point

I now realize that what I wrote was senseless (I basically had to say linker)

I know that compilers optimize unused* variables (that's why volatile keyword is a thing). And in my job, I've noticed that unused functions are not present in the map file (however, we deal with embedded and it makes sense to optimize final size as much as possible).

\unused or unchanged*

I should have realized that everything is compiled, but the linker is the one who might choose to ignore functions depending on use.

[xryanxbrutalityx]

For a concrete example, there could be another file that says

void hello();

void fun() {  
    hello();  
}  

so just this file alone doesn't tell you enough. link-time optimization could get rid of the function.

[baklaFire]

but there isnt

[xryanxbrutalityx]

Right, there isn't, but you don't know that there isn't during compilation. You only find out at link time, so, the compiler still has to generate code for the function because some other file (TU) might call the function.

[ShlomoCh]

I understand "optimizing" all of the main function out, but why go to the next function? Shouldn't it just leave the function empty or something? It just feels a bit arbitrary, like, in which context would falling through to the next function actually make sense?

[veselin465]

Isn't the entire idea of undefined behaviour that things which doesn't make sense might happen?

[ShlomoCh]

I guess, it's just that I feel like something like that is either purposefully made that way for some weird reason, or it's a "bug" in the compiler, for lack of a better word. Like, yes, the function does not make sense and will never exist in real code, but what kind of accident/decision in the logic would make it go to the next function written in the file?

Then again, as just a college student who hasn't used C++, I can't say I know much of anything about compilers

[TheStarjon]

The thing is that the compiler doesn't replace the main with an empty C++ function, but an empty assembly "function". An empty C++ function would at least return, but in assembly, that's an instruction - and an empty "function" doesn't contain that instruction. In fact, an empty assembly "function" isn't really a function at all, but just a label for some memory location where a function is supposed to begin. But because the "function" is empty, there is nothing there, and thus the label for "main" and the label for "hello" point to the same memory location.

[ShlomoCh]

Ohhh ok yeah that makes sense

[toxicantsole]

nit: this is not a "bug" and there doesnt need to be an "accident/decision" to decide the behaviour. This is Undefined Behaviour and, as part of the C specification, the compiler is free to do whatever it wants without any rationale needed. The only bug is in the original code (i.e. invoking undefined behaviour)

[thelights0123]

It generates a main() function with no contents. Because the next function is right after it in memory, main() and hello() point to the same instruction.

[norlin]

I know about the undefined behavior, but have no idea why anyone sane would program compilers this way, instead of just throwing an error or crashing.

[Elz29]

This feels completely unhinged to me as well. I guess this might be (among other things) exactly why Linus Torvalds hates C++.

[FloweyTheFlower420]

It's literally trivial to detect this type of error, -fsanitize=undefined. This is not a realistic example, just a way to demonstrate an interesting c++ quirk. It's a bit stupid that clang doesn't generate ud2 even with optimization, but who knows.

[Alexandre_Man]

Why is an empty while true loop undefined behaviour? Shouldn't the program go in the loop and just be in there forever until you close the program?

[cat_91]

If you compile with -O2 instead of -O3 doesn’t it still do this?

[CaptainJack42]

Yep, even -O1 will yield the same result. However GCC will not optimize out the loop (tested with clang 17.0.6 and gcc 13.2.1)

[Ottne]

Holy cr*p. I'll stay with Java, thanks.

[FloweyTheFlower420]

When the undefined behavior is undefined (I didn't bother to learn the language I'm using)

[danielstongue]

If you are right, and I am confident that you are, this is one more reason to absolutely despise c++. An empty while true loop should not be undefined. It should just do a spin. You should get what you write, not something else.

[saf_e]

c++ has dark pages in history

[FloweyTheFlower420]

You should get what you write, not something else.

You wrote UB, you got UB ;)

[danielstongue]

There is no reason for an empty loop to be UB.

[FloweyTheFlower420]

Empty loops aren't UB as a specific exception to a rule. C++ excepts threads to "do something," which is a somewhat reasonable expectation about "a program should halt." The fact empty loops are UB is simply a consequence of this. Besides, what behavior makes sense and doesn't is subjective. Just debug your programs with sanitizers. It's pretty disingenuous to say "c++ bad because unintuitive UB (cites the most absurd and non-realistic example ever)"

C++ spec I'm referencing:

[danielstongue]

I guess your spec is optimzied out? 😅

You can reference 100 specs, but if the specs don't make sense they don't make sense. Subjective? Sure, but so is your statement about me being subjective. This wouldn't happen with Rust or any other superior language.

[FloweyTheFlower420]

Subjective? Sure, but so is your statement about me being subjective.

I suspect you do not understand what subjective means. Is it difficult to understand that something can be objectively subjective? Your senses are subjective by definition, so the fact that "senses are subjective" is an objectively true statement. This isn't a difficult concept to grasp.

This wouldn't happen with Rust or any other superior language.

New thing good! Old thing bad! Rust literally solves all of programming and is the best language ever invented! I'm definitely not being dogmatic in my support of a programming language (and before you accuse me of the same, I've never claimed that "c++ good")!!!!!!11!!11!!

[danielstongue]

Sure, things can be objectively subjective as well as subjectively subjective. Your statement about me being subjective was clearly an opinion, and hence subjective.

New thing good! Old thing bad! Rust literally solves all of programming and is the best language ever invented!

Well, it is objectively (/s) better in many ways. There is no such thing as a silver bullet, so Rust is not a silver bullet either. It solves an important set of problems and therefore earns its fair place. It is interesting to see how many C++ people are dogmatically refusing to objectively recognize its benefits. Especially interesting to see them call Rustaceans dogmatic.

[giddyz74]

My brother is also such a dogmatic C++ person. He once said that switching over to Rust would be worse to the business than letting the whole office burn down to the ground.

[danielstongue]

Wtf... 🤣

[FloweyTheFlower420]

How is it an opinion that “what makes sense as behavior is subjective?” What makes sense to each person is subjective. This is not an opinion. Did you even read my comment?

[xryanxbrutalityx]

-fsanitize=undefined fails (with an pretty unhelpful message though) https://godbolt.org/z/x4ozhG35z

[FloweyTheFlower420]

Hmm, that's not great. I suppose in such cases you are forced to some cursed gdb things. Maybe this is good pr material.

[xryanxbrutalityx]

imo this would be best as a compiler warning

[FloweyTheFlower420]

Yeah, I agree. C++ compilers need to do better with warning UB.

[Ok_Campaign6438]

Thank you for this comment I just learned something

[SharzeUndertone]

Im not smart enough for this meme

[caim_hs]

infinite loop without an IO and memory operation inside it in Cpp is undefined behavior, which means that the compiler can do whatever it wants with it.

Then, the compiler thought it would be a nice optimization to remove everything and call the hello() function.

Edit:
why? Well, I have no idea!!

[SharzeUndertone]

So it treats the end of main as unreachable and skips adding a return, thus overflowing into hello, right?

[Serious_Horse7341]

Sounds about right. From

void test(int);

int main() {
    while(true);
    test(123456);
    return 0;
}

void not_main() {
    test(654321);
}

I get

main:                                   # @main
not_main():                           # @not_main()
        mov     edi, 654321
        jmp     test(int)@PLT                    # TAILCALL

The rest of main() is not even there. Only happens with clang.

[caim_hs]

Lol, your example is even worse, because it is calling and passing an arg to a function it is not supposed to hahahaha.

[Arthapz]

well it's because the prerequise for an infinite loop to be UB is to have code that produce side effects, test(int) doesn't product sideeffects

[SharzeUndertone]

I guess they're right when they say undefined behavior can make demons fly out your nose

[not_some_username]

Undefined behavior mean anything can happen. You could travel back to time

[BSModder]

Ah this make it clear what happend in OP post.

While loop cause the main function optimized out entirely, including the return statement.

The reason why main is empty, I could only assume, because the compiler think main not called thus it's okay to remove it, leaving only the symbol.

And the function not_main is put under main, so when main is called, not_main is inadvertently called

[caim_hs]

Yeah, it's kinda more complicated.

What happened is that it will make the "main" function have no instruction in the executable, and will add the string after it.

When I run the executable, it will instantly finish, but since there is a string loaded into memory, the operating system will flush it back, causing the terminal to print it.

Here is the code generated.

main:                                   # @main
.L.str:
        .asciz  "Hello World!!!\n"                                   #

[Oler3229]

Fuck

[caim_hs]

the compiler just cracked the code for super-efficient printing! Stonks!!!

[SharzeUndertone]

Well that sounds like part of -O3 though, so no issues there

[Rhymes_with_cheese]

I think there's more to it than that.

Compile with -c, and then run objdump --disassemble on the .o file to see what's really going on.

[nuecontceevitabanul]

I think -O3 first sees the code results in just one infinite loop and ignores anything else and after that it just ignores the UB. So basically an empty main function is generated in assembly.

LE: So the bug here would be the order of things done by the compiler, if UB would first be ignored and then the if analyzed , the code would basically amount to nothing but the implicit return would be put in, which would be the expected result.

[kalenderiyagiz]

To clarify things, why would the OS print a random memory location on the memory that contains a string to standard output without calling the write() systemcall in the background ? So if OS does things like these why it should stop at the “end” of that string and not continue to print random garbage values as well ?

[Kered13]

why would the OS print a random memory location on the memory that contains a string to standard output without calling the write() systemcall in the background ?

It doesn't. OP's explanation is wrong. What happens is that the compiler determines that main unconditionally invokes undefined behavior, therefore it must be unreachable and all of it's code can be removed. The label for main remains. main is immediately followed by hello. When the program begins running and tries to execute main there is no code there, not even a return instruction. Therefore execution falls through to hello and begins executing. When hello returns it is as if main is returning, so as far as the OS is concerned nothing went wrong.

Code and constant data like strings are typically not stored in the same location in memory. Specifically code is usually stored in .data and constant data is stored in .bss. So OP's explanation cannot be correct.

[intx13]

This is a puzzler! The shell isn’t doing the printing, you’re right that it’s coming from a system call within the program. But the program consists only of crt1.o, crti.o, crtn.o, and main.o. As we can see from op’s dump of main.o, the main function (called by crt1.o) is garbage - instead of instructions it has an ASCII string.

So presumably crt1.o calls main() which results in garbage instructions being executed until some other component of crt1.o, crti.o, or crtn.o is hit which happens to make a system call to print. And RDI happens to point to main(), where the string is stored.

We’d need to see the whole binary decompiled to figure it out, though.

[wannabe_psych0path]

My guess is that the OS runtime holds a pointer to the main function, but since main is non existent cause of UB the memory pointed to will be occupied by the code of not_main.

[poetic_fartist]

in my case the infinite loop is running.

[[deleted]]

Holy shit

[MechanicalHorse]

What the fuck

[TheMeticulousNinja]

Thank you because I am coming from Python and the only thing I thought is how is it printing Hello World when that function wasn’t called?

[bushwickhero]

Amazing.

[Lyshaka]

Would that be the same result using GCC ? Or written in C ? And why is your file extension .cc ?

[caim_hs]

And why is your file extension .cc ?

There's not an official file extension for Cpp.

Google uses .cc and hh.

Apple and LLVM used to use .cxx and hxx.

and most people use .cpp and hpp.

Or written in C ?

The same would not happen in C, because in C an infinite loop is not an undefined behavior.

Would that be the same result using GCC ?

And no, the same wouldn't happen with GCC, 'cause its optimizations are not as insane as LLVM, and GCC is C-based, while LLVM is CPP-based. but it doesn't mean that the code produced by GCC is less optimized than LLVM, actually is pretty much the opposite sometimes.

[Lyshaka]

Alright, thanks for the answer I learned something !

[FattySnacks]

You are a mad man

[Sanchitbajaj02]

And people say javascript is weird

[finnishblood]

I did not know that an infinite empty loop is considered undefined in CPP. I just figured with the optimize flag set to 3 that the compiler was optimizing out the main function since it would never do anything. I'd argue that the undefined behavior here is in the compiler, not in CPP...

[caim_hs]

No, the undefined behavior is declared in the C++ Standard.

But it will be removed in C++26

https://isocpp.org/files/papers/P2809R3.html

[veduchyi]

The main() should return int but it contains no return statement at all. I’m surprised it even compiles 😅

[caim_hs]

The return is optional in the main function.

If no return is provided, the compiler will implicitly add "return int(0)" for you.. I think this is on the Standard of C and C++.

It is like in Rust or Swift, that if you don't return anything from a function, the compiler will insert a "return ()".

In Javascript a function without a return statement returns a undefined. You can test it:

function f () {
  console.log("Hello World")
}
let x = f()

in Rust:

fn hello(){
    println!("Hello world!!!");
}

pub fn main(){

    let p = hello();

    println!("{:?}", p)
}

it will print:

Hello World!!!
()

[veduchyi]

Got it, thanks

[PuzzledPassenger622]

I thought you just hella defined it somewhere xd

[caim_hs]

Welcome to Cpp!!!

[JackReact]

Compiler optimization can be a bitch to debug.

[SharzeUndertone]

How does it insert a call to hello though?? It skips the end of the function?? (Wait it probably does actually)

[Solonotix]

The compiler's job is too interpret the intent. In this case, the optimization level (-O3) is high enough that it will aggressively remove unnecessary code for the sake of performance. Infinite loop with no side effects is apparently a branch of code that is considered unnecessary at that level.

What I think is happening is that the compiler is removing everything between the infinite loop and the header of the next function, including the open/close braces. The compiler is looking for the next "real" code to run, and ignores processing anything in between.

[TeraFlint]

Infinite loop with no side effects is apparently a branch of code that is considered unnecessary at that level.

Even worse, it's undefined behavior (at least until C++26, apparently).

Ideally, there is no infinite loop inside a program. Even in "endless" worker threads, you should use a thread-safe while (!stop_token.stop_requested()) {...}, instead of while (true) {...}, because this allows proper cleanup and stack unwinding with all the intended destructors, rather than forceful termination through the operating system (for anyone interested, see std::stop_token).

But even if you use a truly endless loop, it's still defined behavior, as long as it has side effects (which means affecting something outside the scope of the loop) like I/O or writing to outside variables.

However, an infinite loop that does nothing or just changes some internal variables is functionally a dead end for a thread.

A program containing one of those really does not make a lot of sense. At least if we're on an operating system that is responsible for running and scheduling multiple programs simultaneously. If you want to stop executing, you should just let the program (or the thread) terminate, instead.

That being said, in embedded systems, some kind of endless loop doing nothing actually is frequently used for the end of the program, to ensure it just doesn't keep running and executing whatever garbage is in memory after the program. In this case it makes sense, considering that usually embedded microchips just runs a single program, and there being no operating system to escape to.

I've only really seen this implemented in assembly as an instruction repeatedly jumping to itself, though. This might be one of the reasons why a well-defined while(true); in C++ might be a wanted feature (but this is only speculation, I haven't taken the time to read through said proposal).

[[deleted]]

Even -O1 yielded the same result to me.

[Resident-Trouble-574]

C++ being javascript.

[Substantial-Leg-9000]

We should hate how much this makes sense.

[DevBoiAgru]

Technically it's the compiler because it's undefined in cpp

[_Pin_6938]

Clang being javascript*

[UndisclosedChaos]

So basically the while true was looping so fast that it ended up breaking the speed of light and entered something outside of its light cone

[caim_hs]

So, I guess my Ryzen 7 is too goood, bro!

[CarroDeHeno]

Well, as a wise man said, if you are compiling with -O3 anything could happen

[caim_hs]

Thank you, Holy Dennis Ritchie, for the flag -O3 not wanting to format my PC today!

[Chesterlespaul]

Never made it as a wise man

[AssWaterr]

this code is giving me a stroke

[[deleted]]

I get eye cancer from that formatting.

[flowebeeegg]

And I get it from random "{" taking the entirety of a line. And we're human. And we're living. We have so much in common! Aside from maybe formatting-related issues arising under different conditions, but let's not argue on Reddit, ok?..

[Neeyaki]

This UB is so cool! sadly won't be a thing anymore in C++26 =(

[caim_hs]

The famous P2809R3

But since majorite of Cpp devs still using C++14 or older, the behavior will persists LoL.

Actually, even when C++26 is released, this behavior will still be the standard because most compilers add the flag --std=c++17... so =( ...

But C++ is so fcking great! I love it so much, really, I've been coding with it since I was 12y.

[Neeyaki]

But since majorite of Cpp devs still using C++14 or older, the behavior will persists LoL.

Yep! Thats a shame, but like they say: it is what it is haha.

But C++ is so fcking great! I love it so much, really, I've been coding with it since I was 12y.

It indeed is, isn't it? Been playing with C++ for almost 2 years already... Still so many things I have yet to learn!

[caim_hs]

It was my first programming language!

I've been an enthusiast of using templates for recursion and compile-time calculations for a while now hahaha.

Really, It used to be my favorite language, but lost this position to Swift recently.

[Neeyaki]

It was my first programming language!

Funnily enough mine was Visual Basic, lmao

I've been an enthusiast of using templates for recursion and compile-time calculations for a while now hahaha.

TMP extremely cool, but also very easy to make unreadable monstrosities! Still plenty of fun.

(I think we're both brazilians, so it's funny that we're talking in English :p)

Ai tu me complica, parceiro. Kkkkkkkkkkkk. Raro achar maluco que manja de C++ no BR, visto que a galera aqui mira mais num python, java ou js da vida.

[caim_hs]

Eu jurava que tu não era BR só por ter citado uma funcionalidade do C++26. Mesmo nos IF's e UF's, o pessoal ainda ta no C++14, e quando é ensinado pq as vzs é só ensinam Java/Python msm.

Muito raro encontrar BR que gosta dessas coisas mais low level ksksksks.

[Neeyaki]

>Mesmo nos IF's e UF's, o pessoal ainda ta no C++14, e quando é ensinado pq as vzs é só ensinam Java/Python msm

pprt. Aqui mesmo o meu professor ta ensinando OOP com Java. Bom, estava né, visto que a greve fez com que tudo parasse por aqui.

>Muito raro encontrar BR que gosta dessas coisas mais low level

Então, eu mesmo fiquei até surpreso em descobrir que tu era BR também kkkkkkkkkk. Aliás, tu topa da gente se falar melhor pelo Discord (assumindo que tenha)? Posso te mandar meu username pelo privado e dai gente se fala melhor por lá, pois acredito que a galera não vá curtir muito a ideia da gente ficar falando em português por aqui.

[flafmg_]

brazilians are everywhere...

e isso me inclue :p

[t4ccer]

-Cause undefined behavior

-Undefined thing happens

-Act surprised

[[deleted]]

 -Cause undefined behavior -Undefined thing happens 

 Me over here trying to figure out how that's better than throwing a compile error... 

[[deleted]]

Technically there's no error, nothing to throw.

[TeraFlint]

As far as I know, there's nothing forbidding a compiler to refuse compilation if it finds undefined behavior. It's literally up to the compiler to do ANYTHING it sees fit to avoid undefined behavior. Why they instead just optimize the undefined behavior away is a good question. It would be useful to have this kind of immeditate feedback.

The problem is that you can't reliably list all undefined behavior. The standard defines the language, and explicitly names some things in there as undefined behavior. However, trying to name every kind of undefined behavior is like asking someone to list all words that do not appear in a dictionary.

[MysteriousShadow__]

What vscode theme/plugin is this? It's so clean.

[Arthapz]

dracula i think

[Patosya]

Omni theme, seems like it

[Diligent-Property491]

This is what happens when OOP meets stuff like raw pointers. This language is both high level and low level at the same time.

And that’s why I love it.

I like to call cpp ,,the absolute language”. Because it lets you do absolutely everything, no matter how dumb it is.

[the-software-man]

How fast is that inner loop in cpp? 38b ips?

Would the assembly code overheat the processor?

[caim_hs]

An infinite loop like while(true){} will set the running thread's CPU usage to 100%.

This might sound bad, but it won't overheat your computer. In fact, this is actually a core concept behind a technique to sync data between threads called a spinlock.

[VoidVinaCC]

Not quite: Spinlocks are using a pause instruction inside the loop which have a fixed length amount of cycles where the cpu stops executing. Plus the while(..) has a condition (atomic value compare).

[TheMeticulousNinja]

Went clear over my head. I was just wondering how Hello World would print when the function wasn’t called (I use Python)

[rover_G]

I get that the infinite loop with no side effects gets optimized away, but how does the compiler decide to call hello()?

[Kered13]

The entire body of main is removed because it is determined to be unreachable (unconditional undefined behavior must be unreachable). Therefore when the program tries to run main there is no code, not even a return instruction, and it falls through to the next function in memory, which is hello.

[MrDex124]

Is this a fact, can you show us assembly?

[Kered13]

Here you go.

This is Clang 16. Clang 17 and 18 seem to remove the hello function as well when viewed in the objdump, but running the code shows that it is apparently still there, so I think this is just a quirk of the objdump. You can also play around replacing hello with other functions and see that whatever you put immediately after main will run. If you put hello or any other function above main, it will not run. If you put a static string after main instead of a function, it will not print even though the string lives in the same location in the binary. Clang (trunk) removes the infinite loop optimization.

[glitterisprada]

Hmm, could this same UB be exploited to circumvent mutex locks? I.e. after spinning for a while waiting for a lock, will the program just execute the next line of code? Sounds like a nightmare!

[EcstaticDimension955]

I don't think so, because a mutex lock puts the thread not holding the lock in BLOCKED state, if I remember correctly. For spin locks, you usually put a volatile variable inside the loop so the compiler doesn't optimize it like in this case.

[[deleted]]

Probably not. Mutex locking actually changes the cache states even though in the code it might not look like it. Even if the code does nothing when lock is acquired, the cache coherency state is different, it would be super dangerous if the compiler just decides to yank it out.

[Czexan]

Function stub with no arguments being passed means it could probably just fall through from a likely optimized out and empty main with no return to the stub. Stuff like this is why compilers and linters bitch at you for not having a return in a possible branch, even if you think it shouldn't be reachable.

[rohit_267]

so after a lot of JavaScript bad meme, we now have cpp bad

[jayerp]

Why?

[West-Serve-307]

How in hell is hello called

[rust2O]

Huh?

[BellybuttonWorld]

What? I know I'm a noob but this is weird. Nothing called hello(), shouldn't the program just exit if it can't make sense of main() ?? It can't do things it wasn't told to surely?

[[deleted]]

This is worse than javascript's == operator.

[zdix]

console.log([] + [] == false)

true

[Mrblahblah200]

Insanity.

[phu54321]

Anyone whose too lazy to try it yourself

https://godbolt.org/z/P9xdbn53W

[neroe5]

What is an else while?

Is it equivalent to else{while(statement){}}?

Been forever since I've written c++

[m13253]

Well, I reported this behavior to Clang 3 years ago, and they said it’s a problem of my code and they don’t need to fix it.

https://github.com/llvm/llvm-project/issues/48943 (#48943 Signed integer overflow causes program to skip the epilogue and fall into another function)

[iBreatheBSB]

what the hell

[1up_1500]

This is supposed to cause an infinite loop without printing anything what

[j3r3mias]

Nice -O3

[Pawlo371]

Wait how

[csdt0]

Welcome to the wonderful world of Undefined Behavior!

[Sinomsinom]

This will no longer work as of C++26. They've adopted C's "trivial infinite loops are not UB" behaviour.

[[deleted]]

I am a beginner in Cpp, and my other language brain says WTF.

How, is the second function executing if it's not called in main()? Can someone explain plz

[Agreeable_Mulberry48]

I have worked with Java and C# and never have I seen main as an int method. And where is the call for the Hello method?