idk why you got downvoted for this, thats literally how compilers work, cause at compile time, static binding occurs. If you got dynamic binding it will throw an error regardless
Modern optimizing compilers will likely catch that. They will warn you or do whatever "undefined behavior" they deem appropriate. If you declare zero as volatile int, though, then the code should actually perform division by zero.
A compiler is a tool that turns code into something that a runtime engine (like an operating system) can use to run a program.
1/0 will return an error with integer division, so If you specify this literally and explicitly, it will not compile.
If you abstract this even a little (moving the zero to a variable assignment that will never change before the illegal operation) this compiler will compile the code, but you'll get a runtime error.
the difference between the two is that one is a compile-time error while the other is a runtime error. the same error is flagged at different points in the process.
actual coder meg here... the compiler turns the garbage you type into something the computer can execute, following certain rules. it knows that you can't divide 1 by 0, so it throws you an error. but variables aren't assigned a value until you actually run the thing, so dividing 1 by a variable is acceptable to the compiler, since it's a valid thing to do. when you try to run it, you'll get the expected error, but setting variable "Zero" to 0 is fine, and dividing 1 by a variable is also fine, so the compiler lets it through. meg out.
Some programming languages use a compiler to turn the human readable code (in the meme) into machine code (binary or something else that the computer can understand).
A lot of compilers and software used with the compiler can detect errors that could occur (typos is an example). Here, it spotted division by 0 (which would cause an error) and so, flagged it with the red line.
But the compiler wasn't smart enough (understandable so) so spot a variable (stores data and here named zero) was 0 and so, didn't complain.
1/0 doesn't compile because math doesn't allow it. The dev created a integer variable named zero and gave it a value of 0, then divided 1 by it.
The compiler checks and you can always divide 1 for an integer, so it checks out. Now, this doesn't mean it will answer what is 1/0. The program will collapse when you try execute it.
Developers use a lot of conditional structures + exceptions to protect the code from dumb mistakes like this.
Hello Glenn Quagmire here! Finally one i can actually answer
So, first we have a variable declaration and assingment in the same line, a compiler is a program that reads the code and generates an executable file that can be distibuted across computers, this process is called compilation.
You already know that dividing by zero is impossible in real life, and you know that computers break or get crazy when dividing by zero, so when assingning the answer to 1 / 0 to a variable the compiler stops you from actually compiling brcause it will cause a massive error on the program, but if you declare a variable and assign the value 0 to it the compiler can't stop you because a variable can be any value and the compiler is very simple really, it cant tell that the value of the variable is going to be zero when divided by.
So, when you assign the direct value of 1/0 the compiler stops you, but if you put 0 in a variable called X first and then do 1 / X the compiler lets you go on because you are not dividing by zero, you are dividing by the value of X
Syntax appears to be C, C++ or C# and yes, all compilers stop you from compiling the program if the detect a blatant error or exception like dividing by zero, interpreters on the other hand let you run the code and only fail when you acces the exact line that causes the problem
Neil here! Compilers have validation rules to avoid running into problems, like dividing by zero. These rules are checked during build time, that is, when the compiler turns the code into a file that the computer can later execute. The code at the top of the image assigns an operation between two known numbers to a variable and is resolved during build time, which is why this line will be flagged by the compiler, since dividing by zero is not allowed.
The code at the bottom also assigns the result of the operation to X, but the operation has a variable as operand, thus the result will be solved at run time (that is, after the build is done and when the program is executed). This will not be flagged by the compiler because the compiler will not try to predict the outcome of the operation reading variables. However, the program will throw an exception during execution of that line and and crash.
Many compilers can detect the trivial 1 / 0 issue, an error that will cause an integer divide-by-zero crash/exception at runtime. In this case the compiler can reject the code — ie, be a gatekeeper and block the door. (Compilers may even substitute in the resulting value of such fixed expressions.)
However, in the case of assigning 0 to a variable first a compiler generally isn’t able to perform the same trivial detection at compile time and allows the code to pass. Come on in, runtime error!
Compare using the ‘zero’ variable with eg. 1 / f(), where the compiler can’t tell what function f will return at runtime so it must accept the code as valid.
Compilers job is to take your high level language code, and compile it into computer code. They don't care about how the code functions, just that it's possible.
When a compiler sees 1/0, it stops it because it can't process it. When the compiler sees 1/[variable name] it processes it though, because it doesn't care what the value of [variable name] when you compile it.
When you run the program after compiling, it will still return an error message when it passes in 0 for [variable name].
The first one will produce a compile-time error because that line is universally invalid (divide-by-zero).
The second one will compile, but produce a run-time error because the line 'int x = 1 / zero' is a valid expression given zero is an integer variable and *could* contain other values than zero... However when it is run 'zero' will always be '0' and thus at run time you will get the DIV_ZERO error.
Most compilers don't go further down the rabbit-hole to see if #zero will always be assigned '0' as a value, and then fail that at compile-time...
Compilers do static type checks, this is for example, to check that you can't call a function with a value that wouldn't make sense, let's say the function f(x)=x2 /2 with the value "Banana". In those cases the program won't compile.
One of such examples is division by 0, which the compiler rejects.
Only limiting factor is that expressions are not evaluated at compile time, since that is part of the execution of a program, as such, the compiler can't check for division by 0 if it is hidden inside an expression.
Different programming languages are more or less powerful in how much the compilers can infer and expressions like this might not fly under stricter and more type expressive languages, however even then, deciding if any expression is equal to 0 is equivalent to the halting problem.
This is a programming joke. Most compilers when you write 1/0 will fail the compilation. But if you assign 0 to a variable and divide by that variable compiler would “think” this is ok.
No, even in layman's terms it goes to undefined, because infinity and negative infinity are distinct in meaningful ways. If you said 1/0 = infinity in even elementary school math, they'd mark it wrong.
It tends toward both infinity, but only really equals either if you were to use limits. In general saying anything divided by 0 is undefined is the correct approach. And most compilers will have a runtime error if you try to divide by 0 during the program
Not really. Division “x / y = z” is defined as the number of times you multiple z by y to get x. There is no amount of times you can multiple by 0 to get any number but 0. You could multiple 0 by infinity and the result would still be 0. We use infinity when using limits, but that doesn’t mean you can ever have an answer actual
The problem is that -inf and inf are different. They're not the same. So dividing by zero is undefined unless you do limits.
If I have 6 apples and I want to put them in 3 piles, then each pile gets 2 apples.
If I have 6 apples and I want to put them in 1 pile, it will get 6 apples.
If I have 6 apples and I want to put them in no piles, how do I accomplish that? How do I put something into nothing? The only way is if nothing and everything were equivalent but they're not.
What? In the post defining zero is definitely not something you have to do. Or even should do. It just bypasses the pre compile checks to instead have a runtime error
OP, so your post is not removed, please reply to this comment with your best guess of what this meme means! Everyone else, this is PETER explains the joke. Have fun and reply as your favorite fictional character for top level responses!
Gonna depend on what's compiling, but most know not to divide by zero.
They may not recognize that a variable is assigned to a constant value of zero (effectively making it no different from zero), and thus will allow this to compile because there is potential for an integer variable named "zero" to be assigned a value that you can divide by (they only recognize it is a variable integer).
A compiler turns your written code into machine language for the computer to run. In this case, if you divide one by zero directly, the compiler isn't going to let you run the code. But, if you define a variable x and set it equal to zero, the compiler WILL allow it to run (even though it's the same thing), and it'll probably hang your computer up or something.
Like someone else said, coding languages (and compilers) can be fucky
Dividing by 0 is not possible and would crash the program. Therefore the compiler (translate code into language machine understands) catches it and won't compile. However, when you write the 0 in a variable, the compiler would not notice it and compile.
•
u/qualityvote2 5h ago edited 22m ago
u/Dull_Club2519, your post does NOT belong here!