Computers use binary numbers to represent and process information. Every number stored in a computer occupies a certain number of bits, and the way those bits are interpreted determines the value they represent. One fundamental distinction in computer science is the difference between signed and unsigned numbers. Although both use binary digits, they represent numerical values in different ways.
An unsigned number represents only zero and positive values, while a signed number can represent negative values, zero, and positive values. This difference affects the range of values that can be stored, how binary patterns are interpreted, and how arithmetic operations behave in digital systems. Understanding signed and unsigned numbers is essential for learning computer programming, digital electronics, memory representation, and computer arithmetic.
In this article, we will learn how signed and unsigned numbers differ at a fundamental level, how their binary representations work, and why computers need both types.
1. What Is an Unsigned Number?
An unsigned number is a numerical value that cannot be negative. It represents zero and positive whole numbers.
For example, the following are unsigned values:
0
5
12
100
255
Unsigned numbers are commonly used when a value represents a quantity that cannot fall below zero, such as the number of objects, the size of a file, or the value of a digital counter.
How Unsigned Numbers Work in Binary
In an unsigned binary number, every bit contributes to the numerical value according to its position. The rightmost bit represents (2^0), the next bit represents (2^1), and the pattern continues toward the left.
Consider the 8-bit binary number:
11111111
To calculate its unsigned decimal value, add the powers of two corresponding to the positions containing 1.
| Bit position | Value |
|---|---|
| 7 | 128 |
| 6 | 64 |
| 5 | 32 |
| 4 | 16 |
| 3 | 8 |
| 2 | 4 |
| 1 | 2 |
| 0 | 1 |
Adding these values gives:
128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255
Therefore, the unsigned 8-bit binary number 11111111 represents 255 in decimal.
Every bit contributes a nonnegative value, so the representation cannot express a negative number.
Range of Unsigned Numbers
The range of an unsigned binary number depends on the number of bits available.
For an n-bit unsigned number, the minimum value is 0 and the maximum value is (2^n – 1).
Formula:
Minimum value = 0
Maximum value = (2^n – 1)
Here, n represents the total number of bits.
For example, an 8-bit unsigned number has a range of:
0 to (2^8 – 1)
0 to 255
A 16-bit unsigned number can represent values from 0 to 65,535, while a 32-bit unsigned number can represent values from 0 to 4,294,967,295.
As the number of bits increases, the maximum representable unsigned value also increases.
2. What Is a Signed Number?
A signed number is a numerical value that can represent positive numbers, negative numbers, and zero. Signed numbers are necessary because many calculations involve values below zero.
Examples include:
−15
−3
0
7
25
Signed numbers are useful for representing temperatures below zero, financial differences, changes in position, and mathematical calculations that involve subtraction.
However, a computer cannot simply understand a binary pattern as negative without an agreed representation system. It needs a defined method for interpreting the bits.
Modern computers commonly use a representation called two’s complement to store signed integers.
How Signed Numbers Work in Binary
In an 8-bit signed integer using two’s complement, the most significant bit, or leftmost bit, has a negative weight. Its value is −128, while the remaining bit positions represent positive powers of two.
The bit weights are:
−128, 64, 32, 16, 8, 4, 2, 1
Consider the binary pattern:
11111111
If interpreted as an unsigned number, its value is 255.
If interpreted as an 8-bit signed two’s-complement number, its value is −1.
This happens because the signed interpretation uses the following calculation:
−128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = −1
The binary pattern itself has not changed. Only its interpretation has changed.
This is one of the most important concepts in understanding signed and unsigned numbers: the same sequence of bits can represent different numerical values depending on the data type used to interpret it.
Range of Signed Numbers
For an n-bit signed integer using two’s complement, the minimum and maximum values are:
Minimum value: (-2^{n-1})
Maximum value: (2^{n-1} – 1)
One bit position effectively contributes a negative weight, leaving a range that includes both negative and nonnegative values.
For an 8-bit signed integer:
Minimum value = (-2^7 = -128)
Maximum value = (2^7 – 1 = 127)
Therefore, the range is −128 to 127.
A 16-bit signed integer typically ranges from −32,768 to 32,767, while a 32-bit signed integer ranges from −2,147,483,648 to 2,147,483,647.
These ranges apply to standard two’s-complement signed integers.
3. The Fundamental Difference Between Signed and Unsigned Numbers
The main difference is not necessarily the number of bits used. It is how the available bit patterns are assigned numerical meanings.
For example, both signed and unsigned 8-bit integers occupy eight bits. Each type has (2^8), or 256, possible bit patterns. However, the two types interpret those patterns differently.
An unsigned 8-bit integer uses all 256 patterns to represent values from 0 to 255.
A signed 8-bit two’s-complement integer uses the same 256 patterns to represent values from −128 to 127.
The signed representation assigns half of the patterns to negative values and the remaining patterns to zero and positive values. The unsigned representation assigns all patterns to nonnegative values.
Comparison Table
| Feature | Signed number | Unsigned number |
|---|---|---|
| Represents negative values | Yes | No |
| Represents zero | Yes | Yes |
| Represents positive values | Yes | Yes |
| Typical 8-bit range | −128 to 127 | 0 to 255 |
| Number of possible 8-bit patterns | 256 | 256 |
| Common uses | Temperatures, differences, coordinates | Counters, sizes, nonnegative quantities |
The table demonstrates that neither type has more possible bit patterns when both use the same number of bits. The difference lies in how those patterns are distributed across the numerical range.
4. Why Does an Unsigned Number Have a Higher Maximum Value?
Suppose a computer stores an integer using eight bits. Each bit can be either 0 or 1, giving a total of 256 possible combinations.
An unsigned number uses every combination for a nonnegative value. Its range begins at zero and extends to 255.
A signed two’s-complement number must also represent negative values. Consequently, its range extends below zero, reducing the maximum positive value to 127.
Compare the ranges:
Unsigned 8-bit: 0 to 255
Signed 8-bit: −128 to 127
The unsigned type can represent larger positive values because it does not need to represent negative values.
This does not mean that signed numbers use extra bits to store the sign. In a fixed-width two’s-complement representation, the sign is encoded within the same bits used to represent the value.
For this reason, choosing between signed and unsigned numbers is often a decision about which numerical range is appropriate for a particular task.
5. Understanding the Same Binary Pattern in Both Systems
One of the clearest ways to understand the difference is to examine a few binary patterns.
Consider the following examples, assuming an 8-bit representation.
| Binary pattern | Unsigned value | Signed two’s-complement value |
|---|---|---|
| 00000000 | 0 | 0 |
| 00000001 | 1 | 1 |
| 01111111 | 127 | 127 |
| 10000000 | 128 | −128 |
| 11111110 | 254 | −2 |
| 11111111 | 255 | −1 |
Notice that binary patterns beginning with 0 represent the same nonnegative values in both systems. Patterns beginning with 1 represent values from 128 to 255 in the unsigned system, but negative values in the signed two’s-complement system.
The leftmost bit is called the most significant bit (MSB). In a signed two’s-complement integer, it indicates whether the value is negative or nonnegative: an MSB of 1 indicates a negative value, and an MSB of 0 indicates a nonnegative value.
In an unsigned integer, the MSB contributes a positive weight of (2^{n-1}), just like the other bit positions contribute their corresponding positive weights.
This distinction explains why interpreting binary data requires knowing its type, not just its bit pattern.
6. How Computers Represent Negative Numbers
There are several historical and theoretical approaches to representing signed binary numbers, including sign-magnitude, one’s complement, and two’s complement.
Modern general-purpose processors commonly use two’s complement for signed integers because it supports efficient arithmetic and provides a single representation for zero.
To find the two’s-complement representation of a negative integer:
Write the positive value in binary using the required number of bits.
Invert every bit, changing 0 to 1 and 1 to 0.
Add 1 to the resulting binary pattern.
For example, represent −5 using eight bits.
Step 1: Write positive 5 in binary.
00000101
Step 2: Invert every bit.
11111010
Step 3: Add 1.
11111010 + 1 = 11111011
Therefore, the 8-bit two’s-complement representation of −5 is:
11111011
When interpreted as an unsigned integer, this same pattern equals 251. When interpreted as a signed two’s-complement integer, it equals −5.
This example reinforces the fundamental idea that a bit pattern does not carry an independent numerical meaning. Its meaning depends on the representation and interpretation rules.
7. How Signed and Unsigned Numbers Affect Arithmetic
Signed and unsigned types also influence how computers interpret arithmetic results. The underlying hardware may perform similar binary operations, but the resulting bit patterns can have different meanings.
Addition
Consider the 8-bit pattern 11111111.
As an unsigned number, it represents 255. As a signed two’s-complement number, it represents −1.
Adding 1 produces a nine-bit mathematical result in an unrestricted representation, but an 8-bit operation retains only eight bits if the calculation wraps modulo 256.
The resulting 8-bit pattern is:
11111111 + 00000001 → 00000000
For an unsigned 8-bit calculation using wraparound arithmetic, 255 + 1 produces 0.
For a signed 8-bit calculation, −1 + 1 produces 0.
The same bit-level addition produces the same pattern, but the mathematical meanings of the inputs differ.
Overflow
Overflow occurs when a mathematical result falls outside the range that a fixed-width type can represent.
For an unsigned 8-bit integer, adding 1 to 255 exceeds the maximum representable value. Under wraparound arithmetic, the stored result becomes 0.
For a signed 8-bit integer, adding 1 to 127 exceeds the maximum signed value. In a fixed-width two’s-complement operation, the resulting bit pattern is 10000000, which represents −128 if interpreted as signed.
In programming languages, the precise behavior of overflow depends on the language and operation. For example, unsigned arithmetic in C is defined to wrap modulo the type’s range, while signed integer overflow in C is generally undefined behavior. Other languages may define different rules or detect overflow.
Therefore, programmers must consider both the data type and the rules of the programming language when performing arithmetic.
8. When Should Signed Numbers Be Used?
Signed numbers are appropriate when a value may legitimately be negative.
Common examples include:
Temperature: A temperature may fall below zero degrees, so a signed number is suitable for representing Celsius temperatures.
Position and movement: A coordinate may be positive or negative depending on its position relative to an origin.
Financial differences: A change in balance, profit or loss, or difference between two quantities may be positive or negative.
Mathematical calculations: Subtraction, equations, and many scientific calculations require negative values.
Signal processing: Some digital signal representations use signed samples to describe values that vary above and below a reference level.
In each case, the possibility of negative values is a meaningful part of the data, making a signed representation useful.
9. When Should Unsigned Numbers Be Used?
Unsigned numbers are useful when negative values are not meaningful and a larger nonnegative range is desirable.
Examples include:
Counters: A counter that records completed events may need to represent values from zero upward.
File sizes: A file’s size is a nonnegative quantity, although the appropriate integer type depends on the system and expected size.
Array indexes and lengths: Some programming languages and libraries use unsigned types for sizes or indexes, while others use signed types. The choice must match the language’s conventions and required range.
Digital hardware registers: Some registers store nonnegative counts, bit fields, or measurements for which an unsigned interpretation is appropriate.
Pixel values: Many image formats represent channel intensities using unsigned integers, such as 8-bit values from 0 to 255.
Unsigned numbers should not automatically be considered safer or better. If a calculation can produce negative values, using an unsigned type may introduce unexpected behavior, particularly in comparisons and subtraction.
10. How Signed and Unsigned Numbers Work in Programming
Programming languages allow developers to choose data types according to the values they need to represent. The exact type names vary between languages.
For example, C and C++ provide signed and unsigned integer types. Java provides signed integer types such as byte, short, int, and long, but does not provide corresponding primitive unsigned integer types for all of these widths. Python’s built-in int supports arbitrary-precision integers, subject to available memory, rather than using a fixed-width signed or unsigned integer type by default.
Consider this conceptual example using an 8-bit value:
Unsigned interpretation:
The binary pattern is identical. The selected type determines its interpretation.
Programmers must also be careful when converting between signed and unsigned types. A conversion may preserve the underlying bit pattern in some contexts while changing the numerical value used to interpret it. Rules depend on the programming language, the source and destination types, and the conversion operation.
For example, converting the signed 8-bit value −1 to an unsigned 8-bit value in a system using the usual modulo conversion rule produces 255. Although the bit pattern can remain 11111111, the interpreted value changes.
Understanding these rules helps prevent bugs involving comparisons, arithmetic, array indexes, and data received from files or networks.
11. Common Misconceptions About Signed and Unsigned Numbers
Misconception 1: Signed Numbers Always Use an Extra Sign Bit
A signed integer does not necessarily require an additional bit beyond the specified width. An 8-bit signed integer still occupies eight bits. In two’s complement, the sign is encoded in the same eight bits.
Misconception 2: Unsigned Numbers Are Always Larger
Unsigned numbers have a higher maximum positive value when compared with signed two’s-complement integers of the same width. However, they cannot represent negative values. Whether the unsigned type is more suitable depends on the application.
Misconception 3: A Binary Pattern Has Only One Decimal Value
A binary pattern can have different values under different interpretations. For example, 11111111 represents 255 as an 8-bit unsigned integer and −1 as an 8-bit signed two’s-complement integer.
Misconception 4: Signed and Unsigned Arithmetic Always Behave the Same Way
The underlying binary operations may be similar, but comparisons, overflow rules, type conversions, and the interpretation of results can differ. These differences matter in programming and hardware design.
Conclusion
At a fundamental level, signed and unsigned numbers differ in how they interpret the available binary bit patterns. Unsigned numbers represent zero and positive values, allowing the full set of patterns to be used for nonnegative quantities. Signed numbers represent negative values as well as zero and positive values, with modern computers commonly using two’s complement to encode signed integers.
For an 8-bit representation, an unsigned integer ranges from 0 to 255, while a signed two’s-complement integer ranges from −128 to 127. Both use the same eight bits and have 256 possible bit patterns, but those patterns are assigned different numerical meanings.
Understanding this distinction is essential for working with binary arithmetic, programming languages, digital hardware, memory, and data representation. By selecting the appropriate type and understanding its range, programmers and engineers can represent values correctly and avoid many common numerical errors.
FAQs
1. What is the main difference between signed and unsigned numbers?
The main difference between signed and unsigned numbers is the range of values they can represent. A signed number can represent negative values, zero, and positive values, while an unsigned number represents only zero and positive values. For example, an 8-bit signed integer using two’s complement ranges from −128 to 127, whereas an 8-bit unsigned integer ranges from 0 to 255. Both types use eight bits, but they interpret the available binary patterns differently. Choosing the correct type depends on whether negative values are necessary for the intended application.
2. Why do computers use signed and unsigned numbers?
Computers use signed and unsigned numbers because different applications require different numerical ranges. Signed numbers are useful for calculations involving negative values, such as temperatures below zero, coordinates, and changes in measurements. Unsigned numbers are suitable for nonnegative quantities, such as counters, file sizes, and pixel intensities. Providing both types allows programmers to represent data more appropriately within a fixed number of bits. Understanding these types also helps developers avoid errors involving arithmetic, comparisons, and conversions. The choice depends on the nature of the data and the range of values that must be represented.
3. What is the range of an 8-bit signed and unsigned integer?
An 8-bit unsigned integer ranges from 0 to 255 because its maximum value is calculated using the formula (2^8-1). An 8-bit signed integer using two’s complement ranges from −128 to 127. Its minimum value is (-2^7), and its maximum value is (2^7-1). Both types can represent 256 distinct bit patterns, but they assign different numerical meanings to those patterns. The unsigned type uses every pattern for nonnegative values, while the signed type uses patterns to represent negative and nonnegative values. These ranges are important when selecting data types in programming.
4. Can the same binary number represent different values?
Yes, the same binary pattern can represent different numerical values depending on whether it is interpreted as signed or unsigned. For example, the 8-bit binary pattern 11111111 represents 255 as an unsigned integer. When interpreted as an 8-bit signed two’s-complement integer, it represents −1. The bits themselves remain unchanged; only their interpretation differs. This happens because unsigned numbers assign positive weights to all bit positions, while signed two’s-complement numbers assign a negative weight to the most significant bit. Therefore, understanding the data type is essential when interpreting binary data correctly.
5. How are negative numbers represented in computers?
Modern computers commonly represent negative integers using a binary system called two’s complement. To obtain the two’s-complement representation of a negative number, write the positive value in binary using the required bit width, invert every bit, and add one. For example, positive 5 in eight bits is 00000101. Inverting the bits gives 11111010, and adding one produces 11111011. Therefore, 11111011 represents −5 as an 8-bit signed integer. Two’s complement simplifies arithmetic operations and provides a single representation for zero, making it a practical choice for modern computer processors.
6. Why can unsigned numbers represent larger positive values?
Unsigned numbers can represent larger positive values than signed two’s-complement numbers of the same width because they do not need to represent negative values. Every available bit pattern is assigned to a nonnegative integer. For example, an 8-bit unsigned integer can represent values from 0 to 255, while an 8-bit signed integer ranges from −128 to 127. Both types have 256 possible patterns, but the signed type uses some patterns for negative values. Consequently, its maximum positive value is smaller. Unsigned integers are useful when the application requires a larger nonnegative range.
7. What happens when a signed or unsigned number overflows?
Overflow occurs when an arithmetic result exceeds the range representable by a fixed-width integer type. For example, adding one to 255 exceeds the maximum of an 8-bit unsigned integer. Under wraparound arithmetic, the result becomes zero. Similarly, adding one to 127 produces the bit pattern 10000000 in an 8-bit two’s-complement operation, which represents −128 if interpreted as signed. However, programming languages differ in their overflow rules. Some define wrapping behavior for particular types, while others may treat signed overflow as an error or undefined behavior. Developers should understand their language’s rules.
8. When should a programmer use signed numbers instead of unsigned numbers?
A programmer should use signed numbers when a value may be negative or when calculations require movement above and below zero. Examples include temperatures, financial differences, coordinates, and many scientific measurements. Signed integers are also useful for subtraction results that may fall below zero. Unsigned numbers are better suited to quantities that cannot meaningfully be negative, such as certain counters, bit fields, and pixel intensities. However, the correct choice depends on the programming language and application requirements. Selecting an appropriate type helps prevent range errors, unexpected conversions, and problems with arithmetic operations.
9. Does a signed integer require an extra bit to store its sign?
No, a signed integer does not necessarily require an extra bit to store its sign. In a fixed-width two’s-complement representation, the sign is encoded within the available bits. For example, an 8-bit signed integer uses eight bits, just like an 8-bit unsigned integer. The most significant bit has a negative weight in the signed representation, allowing the complete bit pattern to represent a negative value when appropriate. An unsigned integer uses that same bit position as a positive-weight position. Therefore, signed and unsigned integers of equal width have the same number of possible bit patterns.
10. What happens when a signed number is converted to an unsigned number?
Converting a signed number to an unsigned number can change its interpreted numerical value, especially when the original value is negative. For example, under the usual modulo conversion rule for an 8-bit unsigned integer, converting −1 produces 255. Both values correspond to the binary pattern 11111111 when represented in eight bits, but the signed and unsigned interpretations differ. Conversion rules depend on the programming language and the source and destination types. Programmers should therefore handle these conversions carefully, particularly when working with arithmetic, comparisons, file data, network data, or fixed-width integer types.
