Integer: Difference between revisions
m
→Integer Overflow
Puppydrum64 (talk | contribs) |
Puppydrum64 (talk | contribs) |
||
| (4 intermediate revisions by the same user not shown) | |||
Line 7:
==How Integers Are Stored in Memory==
Typically, the term "integer" has become associated with a 32-bit value, thanks mostly to [[C]], however this is not necessarily the case across all languages and all computer architectures. Most languages stick to this standard, but not all do. Languages that allow for arbitrarily large integers definitely do not. Storing a 32-bit value in memory is simple, the bytes are placed consecutively, starting at the specified memory address (usually this is done by assigning a value to a variable, and the programmer never sees the actual address).
Unlike floats, an integer's binary representation is taken at face value (except sometimes for the leftmost bit, we'll get to that in a moment.) So a binary <tt>1</tt> is 1, a binary <tt>10</tt> is 2, etc.
==Signed/Unsigned==
Integer variables can be either be declared as '''signed''' or '''unsigned''', and this affects how the compiler handles them. CPUs have different ways of comparing values depending on whether a variable is intended to be signed or unsigned. Notice that I said "intended" - the CPU doesn't really know whether your data is meant to be signed or unsigned. This means that the quantity <tt>0xFFFFFFFF</tt> can represent either negative 1 or 4,294,967,295. But which one is it? Most high-level languages lock you into picking one, but at a hardware level it can be whatever you want it to be at any particular moment. (Kind of like the Ace in Blackjack.)
For most programming languages, integer variables (and numeric variables in general) are treated as signed by default (some don't even give you a choice.)
<lang C>int foo; //this is a signed integer
unsigned int bar; //this is an unsigned integer</lang>
==Two's Complement==
Line 15 ⟶ 21:
==Integer Overflow==
And I'm sure you've figured it out by now. Yes, if a signed number gets too big, it suddenly becomes very very small. This is known as integer overflow and occurs when a number crosses over from <tt>0x7F...</tt> to <tt>0x80...</tt> (fill in the dots with Fs/0s depending on the size of your numeric data type.) Luckily, nearly all CPUs have special hardware just for detecting overflow, and do so automatically after every calculation. Here's
<lang asm>MOV EAX,0x7FFFFFFF
ADD EAX,1
Line 23 ⟶ 29:
The <code>jo</code> instruction stands for "jump if overflow" and acts as a conditional <code>GOTO</code> in the event an overflow occurs.
Many high-level languages will do something similar, usually in the form of throwing exceptions. Keep in mind that raising errors on overflow is purely a software convention - the hardware will detect it any time it happens, but the software decides whether the overflow is actually a problem or not. (
==Unsigned Overflow==
| |||