signedness

Signedness refers to whether a numeric type can represent negative values (signed) or only non-negative values (unsigned). It is a fundamental aspect of how integers are stored and manipulated in computer systems. In most modern hardware, signed integers use a two's complement representation, while unsigned integers represent non-negative values by their binary patterns without a sign bit.

For an n-bit type, the ranges differ by sign. A signed n-bit integer typically covers from -2^(n-1) to 2^(n-1) - 1, whereas an unsigned n-bit integer covers 0 to 2^n - 1. These ranges influence arithmetic behavior, value comparisons, and the safe boundaries for range checks. Overflow handling varies by language and type: unsigned arithmetic generally wraps modulo 2^n, while signed overflow is defined differently across languages and often treated as undefined in languages like C and C++, though many implementations exhibit wraparound behavior.

Language and type systems shape how signedness is used and converted. Some languages (such as C and C++) distinguish signed and unsigned integer types explicitly, with particular rules for conversions and promotions that can lead to surprising results when mixing signed and unsigned values. Java uses signed integers for its primitive types and provides unsigned-style operations through library methods rather than distinct unsigned types in the core language. Other languages (like Rust) provide explicit signed and unsigned types with well-defined casting rules. The signedness of a char type is often implementation-defined in C and C++, while in Java a char is a 16-bit unsigned type.

Common pitfalls include comparing signed and unsigned values in the same expression, which can yield counterintuitive results, and casting between signed and unsigned types without understanding the underlying bit patterns. Understanding signedness helps ensure correct range checks, overflow handling, and portability across platforms.