44:"/_next/static/chunks/33yus346z0l_n.js" 45:"/_next/static/chunks/2j22cxchii_xx.js" 46:"/_next/static/chunks/0iv56yrji_20j.js" 47:"/_next/static/chunks/32izpn90gvm22.js" 48:"/_next/static/chunks/3j8bi-zu9bqs4.js" 49:"/_next/static/chunks/1z-pox7hqp2x3.js" 4a:"/_next/static/chunks/20w4eaqlekefm.js" 4b:"/_next/static/chunks/1tn-0fivsxsv1.js" 4c:"/_next/static/chunks/09nq57stwzkgf.js" 4d:"/_next/static/chunks/3m1xjj5kw5fie.js" 4e:"/_next/static/chunks/0gafyzg9j9yqj.js" 4f:"/_next/static/chunks/3k2gyg36fnag_.js" 50:"/_next/static/chunks/3bgoyiso1rhn7.js" 51:"/_next/static/chunks/3cstd6xzfli_o.js" 52:"/_next/static/chunks/253gnmj0-cj17.js" 53:"/_next/static/chunks/0hlb44ca7-4a2.js" 54:"/_next/static/chunks/20329i6m_04t6.js" 55:"/_next/static/chunks/40mq7ggq-ozo4.js" 56:"/_next/static/chunks/082jo-0ajazgr.js" 57:"/_next/static/chunks/2ozcrjb_hh74t.js" 58:"/_next/static/chunks/01a-3hvnqu8wl.js" 59:"/_next/static/chunks/05i8en-x14ibi.js" 5a:"/_next/static/chunks/3m0r7x0jt5wm7.js" 5b:"/_next/static/chunks/2k8pepwc4pxns.js" 5c:"/_next/static/chunks/0wa9m1-tphf9u.js" 5d:"/_next/static/chunks/30jdm3dwz834g.js" 5e:"/_next/static/chunks/0k9bl6dipnsvu.js" 5f:"/_next/static/chunks/18ggtgz2yf759.js" 60:"/_next/static/chunks/0i3-eynrkvqi7.js" 61:I[593304,["$2a","$2b","$2c","$2d","$2e","$2f","$44","$45","$46","$47","$48","$49","$4a","$4b","$4c","$4d","$4e","$4f","$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60"],"OwnedHydration"] 62:T432,**Why sign-magnitude failed:** 1. **Two representations of zero:** `00000000` (+0) and `10000000` (-0) both represent zero, wasting a bit pattern and complicating equality comparisons. 2. **Complex arithmetic circuits:** Adding a positive and negative number requires different logic than adding two positives. The CPU needs to check signs, possibly swap operands, subtract magnitudes, and determine the result sign—significantly more hardware. 3. **Subtraction is not just negation plus addition:** The hardware complexity increases substantially. **Why one's complement failed:** 1. **Still two zeros:** `00000000` (+0) and `11111111` (-0) both represent zero. 2. **End-around carry:** Addition sometimes requires an "end-around carry" where the overflow bit must be added back to the result—additional hardware complexity. Both approaches were actually used in early mainframes. The UNIVAC 1100 series used one's complement, while early IBM systems used sign-magnitude. The industry converged on two's complement because it solves all these problems elegantly.63:T4c6,# Demonstrating two's complement properties # In Python, we can simulate 8-bit two's complement def to_twos_complement(value: int, bits: int = 8) -> str: """Convert a signed integer to its two's complement binary representation.""" if value >= 0: return format(value, f'0{bits}b') else: # Two's complement: 2^bits + value (which handles negative values) return format((1 << bits) + value, f'0{bits}b') def from_twos_complement(binary: str) -> int: """Convert a two's complement binary string to signed integer.""" bits = len(binary) value = int(binary, 2) # If MSB is 1, it's negative if binary[0] == '1': value -= (1 << bits) return value # Examples print("Positive 5:", to_twos_complement(5)) # 00000101 print("Negative 5:", to_twos_complement(-5)) # 11111011 print("Negative 1:", to_twos_complement(-1)) # 11111111 print("Negative 128:", to_twos_complement(-128)) # 10000000 # Verify addition works naturally # 5 + (-3) should equal 2 five = 0b00000101 # 5 neg_three = 0b11111101 # -3 in two's complement result = (five + neg_three) & 0xFF # Mask to 8 bits print(f"5 + (-3) = {from_twos_complement(format(result, '08b'))}") # 264:T47e,#include #include int main() { // BUG 1: Signed/unsigned comparison int x = -1; unsigned int y = 1; if (x < y) { std::cout << "-1 < 1 "; // This WON'T print! } else { std::cout << "-1 >= 1 (unexpected!) "; // This prints! } // Why? -1 is promoted to unsigned, becoming 4,294,967,295 // FIX: Explicit casting with awareness if (x < static_cast(y)) { std::cout << "-1 < 1 (with explicit cast) "; // Correct } // BUG 2: Infinite loop with unsigned counter std::vector vec = {1, 2, 3, 4, 5}; // for (unsigned i = vec.size() - 1; i >= 0; i--) { // INFINITE LOOP! // std::cout << vec[i] << " "; // } // FIX: Use signed type or alternative iteration for (int i = static_cast(vec.size()) - 1; i >= 0; i--) { std::cout << vec[i] << " "; // Correct: 5 4 3 2 1 } std::cout << " "; // BUG 3: Underflow in size calculation unsigned size = 0; unsigned prev = size - 1; // Now 4,294,967,295, not -1! std::cout << "size - 1 = " << prev << " "; // Unexpectedly huge! return 0; }42:["$","$L61",null,{"owner":"anonymous","state":{"mutations":[],"queries":[{"dehydratedAt":1792289445801,"state":{"data":{"json":{"id":"seed_983ae09389fbbd14ed4e363e13915b80","slug":"integer-data-types","category":"Data Structures & Algorithms","topic":"Integer Data Types","title":"Integer Data Types","description":"Master the intricacies of integer representation in computer systems. Understand signed vs unsigned integers, fixed-size storage, overflow behavior, and the cost model of integer operations—essential knowledge for writing robust, efficient code.","difficulty":"BEGINNER","estimatedMinutes":75,"pages":[{"id":"seed_e15f419aed6ba12ca3c3ce513ea0319f","title":"Signed vs Unsigned Integers","order":0,"content":[{"id":"opening-hook","title":"The Fundamental Dichotomy in Integer Representation","content":[{"data":{"content":"When you write `int x = -5;` in code, have you ever paused to consider *how* the computer understands that this value is negative? At the hardware level, computers only have two states—on and off, 1 and 0. There's no special \"negative bit\" or \"minus symbol\" stored in silicon. So how do we represent negative numbers using only binary?\n\nThis seemingly simple question leads to one of the most fundamental concepts in computer science: the distinction between **signed** and **unsigned** integers. Understanding this distinction is not merely academic—it directly impacts the correctness, security, and efficiency of the software you write."},"type":"text"},{"data":{"icon":"Target","title":"What You Will Learn","content":"By the end of this page, you will understand: (1) Why the signed vs unsigned distinction exists, (2) How negative numbers are encoded in binary using two's complement, (3) The range implications of choosing signed vs unsigned types, (4) How to recognize and avoid common bugs related to signedness, and (5) When to choose signed vs unsigned integers in practice.","variant":"info"},"type":"callout"}]},{"id":"core-problem","title":"The Core Problem: Representing Negativity in Binary","content":[{"data":{"content":"Let's start with a fundamental observation: binary numbers, by their natural mathematical definition, can only represent non-negative values. A sequence like `1011` directly maps to the decimal value 11 through positional notation:\n\n$$1 \\times 2^3 + 0 \\times 2^2 + 1 \\times 2^1 + 1 \\times 2^0 = 8 + 0 + 2 + 1 = 11$$\n\nEvery bit contributes a positive power of 2. There's no inherent way to produce a negative result from this scheme. Yet programming requires negative numbers constantly—financial calculations, temperature readings, coordinate systems, and countless other domains depend on values below zero.\n\n**The challenge:** Given a fixed number of bits (say, 32 bits), how do we encode both positive and negative values within the same bit space?"},"type":"text"},{"data":{"icon":"Info","title":"Why Fixed-Size Matters","content":"Computers work with fixed-width integer types (8-bit, 16-bit, 32-bit, 64-bit) because hardware is designed with specific register and memory bus widths. A 32-bit processor naturally handles 32-bit values in a single operation. This fixed width creates a finite space that must somehow accommodate both positive and negative numbers.","variant":"note"},"type":"callout"},{"data":{"content":"**The fundamental trade-off:**\n\nIf you have *n* bits, you can represent exactly $2^n$ distinct values. With 8 bits, that's 256 distinct patterns. The question becomes: how do you *allocate* these 256 patterns?\n\n- **Unsigned approach:** Use all 256 patterns for non-negative values: 0 through 255\n- **Signed approach:** Split the patterns between negative and non-negative values\n\nThis is the essence of the signed vs unsigned distinction. It's not about storing different data—it's about *interpreting* the same bit patterns differently."},"type":"text"}],"titleType":"number","titleNumber":1},{"id":"unsigned-integers","title":"Unsigned Integers: The Natural Binary Interpretation","content":[{"data":{"content":"**Unsigned integers** follow the straightforward positional binary interpretation. Every bit pattern maps directly to its mathematical binary value, and all representable values are non-negative."},"type":"text"},{"data":{"rows":[["00000000","0","Minimum value"],["00000001","1","—"],["00101010","42","—"],["01111111","127","Halfway point"],["10000000","128","—"],["11111110","254","—"],["11111111","255","Maximum value"]],"caption":"8-bit Unsigned Integer Range (Sampling)","headers":["Binary Pattern","Decimal Value","Interpretation"]},"type":"table"},{"data":{"content":"**The range formula for unsigned integers:**\n\nFor an *n*-bit unsigned integer:\n- **Minimum value:** 0\n- **Maximum value:** $2^n - 1$"},"type":"text"},{"data":{"rows":[["8 bits","0 to 255"],["16 bits","0 to 65,535"],["32 bits","0 to 4,294,967,295 (~4.3 billion)"],["64 bits","0 to 18,446,744,073,709,551,615 (~18.4 quintillion)"]],"headers":["Bit Width","Range"]},"type":"table"},{"data":{"content":"**When to use unsigned integers:**\n\nUnsigned types are appropriate when values are inherently non-negative and you want to maximize the positive range:\n\n- **Array indices and sizes** — An array cannot have negative length\n- **Counts and quantities** — You can't have -5 users\n- **Memory addresses** — Addresses are always positive offsets\n- **Bit manipulation** — When treating integers as bit patterns rather than numeric values\n- **Cryptographic operations** — Where modular arithmetic on full-width values is expected"},"type":"text"},{"data":{"icon":"AlertCircle","title":"The Unsigned Subtraction Trap","content":"A classic bug: if `length` is an unsigned integer with value 0, then `length - 1` doesn't produce -1. Instead, it wraps around to the maximum unsigned value (e.g., 4,294,967,295 for 32-bit). This unsigned wraparound is a frequent source of security vulnerabilities in C/C++ codebases.","variant":"warning"},"type":"callout"}],"titleType":"number","titleNumber":2},{"id":"signed-integers-history","title":"Signed Integers: Historical Representation Schemes","content":[{"data":{"content":"Before we examine the modern standard, it's instructive to understand the historical approaches to representing signed integers. Each approach has different trade-offs, and understanding why they were abandoned illuminates the elegance of the modern solution."},"type":"text"},{"data":{"items":["**Sign-Magnitude Representation** — The most intuitive approach: dedicate one bit (typically the leftmost) as a \"sign bit\" where 0 = positive and 1 = negative. The remaining bits represent the magnitude. Example: in 8-bit sign-magnitude, `00000101` = +5 and `10000101` = -5.","**One's Complement** — To negate a number, flip all bits. In one's complement, +5 = `00000101` and -5 = `11111010`. This was used in some early computers.","**Two's Complement** — The modern standard. To negate a number, flip all bits and add 1. We'll explore this in detail."],"title":{"icon":"BookOpen","text":"Historical Signed Integer Representations","type":"icon","color":"primary","variant":"outline-circle"},"variant":"glass"},"type":"list"},{"data":{"content":"$62"},"type":"text"},{"data":{"icon":"Lightbulb","title":"Historical Context Matters","content":"Don't skip this history as \"irrelevant trivia.\" Understanding why two's complement won helps you understand its properties. The design wasn't arbitrary—it was selected because it simplifies hardware implementation while providing clean mathematical properties.","variant":"tip"},"type":"callout"}],"titleType":"number","titleNumber":3},{"id":"twos-complement","title":"Two's Complement: The Modern Standard","content":[{"data":{"content":"**Two's complement** is the universal standard for representing signed integers in modern computers. Nearly every processor—from embedded microcontrollers to supercomputers—uses two's complement for signed integer arithmetic.\n\n**The definition:**\n\nTo find the two's complement representation of a negative number:\n1. Start with the binary representation of the positive magnitude\n2. Invert (flip) all bits\n3. Add 1 to the result\n\n**Example: Representing -5 in 8-bit two's complement**\n\n1. Start with +5: `00000101`\n2. Invert all bits: `11111010`\n3. Add 1: `11111011`\n\nTherefore, -5 in 8-bit two's complement is `11111011`."},"type":"text"},{"data":{"rows":[["01111111","+127","127"],["01111110","+126","126"],["00000010","+2","2"],["00000001","+1","1"],["00000000","0","0"],["11111111","-1","255"],["11111110","-2","254"],["10000001","-127","129"],["10000000","-128","128"]],"caption":"8-bit Two's Complement: Complete Range","headers":["Binary Pattern","Signed Value","Unsigned Value"]},"type":"table"},{"data":{"content":"**Key observations:**\n\n1. **The sign bit:** The most significant bit (MSB) indicates the sign: 0 for non-negative, 1 for negative. But unlike sign-magnitude, this bit *also* contributes to the numeric value.\n\n2. **Only one zero:** The pattern `00000000` uniquely represents zero. There's no wasted \"negative zero.\"\n\n3. **Asymmetric range:** The range is -128 to +127 for 8 bits, not -127 to +127. There's one more negative value than positive values.\n\n4. **Wraparound behavior:** If you increment `01111111` (+127), you get `10000000` (-128). The number \"wraps around\" from the maximum positive to the minimum negative."},"type":"text"},{"data":{"icon":"Sparkles","title":"Why Two's Complement Works","content":"The magic of two's complement: addition works the same regardless of sign. The CPU doesn't need to know whether operands are signed or unsigned—it just adds bit patterns. The interpretation of the result (signed vs unsigned) is up to the programmer/compiler, but the hardware operation is identical.","variant":"note"},"type":"callout"},{"data":{"code":"$63","fileName":"twos_complement_demo.py","languages":[{"label":"Python","value":"python"}],"showLineNumbers":true},"type":"code"}],"titleType":"number","titleNumber":4},{"id":"mathematical-understanding","title":"The Mathematical Elegance of Two's Complement","content":[{"data":{"content":"Two's complement isn't just a clever encoding trick—it has deep mathematical properties that make it ideal for hardware implementation.\n\n**Interpretation formula:**\n\nFor an *n*-bit two's complement number with bits $b_{n-1}b_{n-2}...b_1b_0$:\n\n$$\\text{value} = -b_{n-1} \\times 2^{n-1} + \\sum_{i=0}^{n-2} b_i \\times 2^i$$\n\nThe most significant bit contributes *negative* $2^{n-1}$ instead of positive. This single change transforms unsigned into signed interpretation.\n\n**Example: Interpreting `11111011` (8-bit)**\n\n$$= -1 \\times 2^7 + 1 \\times 2^6 + 1 \\times 2^5 + 1 \\times 2^4 + 1 \\times 2^3 + 0 \\times 2^2 + 1 \\times 2^1 + 1 \\times 2^0$$\n$$= -128 + 64 + 32 + 16 + 8 + 0 + 2 + 1$$\n$$= -128 + 123 = -5$$"},"type":"text"},{"data":{"icon":"Lightbulb","title":"The Modular Arithmetic Perspective","content":"Another way to understand two's complement: it treats integers modulo 2^n. In this view, -1 and 255 are the same number modulo 256. The \"negative\" numbers are just the upper half of the modular number circle, reinterpreted with a bias. This perspective is crucial for understanding overflow behavior.","variant":"tip"},"type":"callout"},{"data":{"content":"**Why the same hardware works for both signed and unsigned addition:**\n\nConsider adding two 8-bit numbers. The CPU performs binary addition with carry propagation:\n\n```\n 00000101 (5)\n+ 11111011 (-5 signed, or 251 unsigned)\n─────────────\n 00000000 (0 signed, or 0 unsigned modulo 256)\n```\n\nThe hardware doesn't \"know\" if these are signed or unsigned—it just adds bits. The result is correct for *both* interpretations:\n- Signed: 5 + (-5) = 0 ✓\n- Unsigned: (5 + 251) mod 256 = 256 mod 256 = 0 ✓\n\nThis unification of addition logic is why two's complement won. It halves the complexity of arithmetic circuits."},"type":"text"},{"data":{"items":["**Unique zero representation** — Only `000...0` represents zero, no wasted patterns","**Same addition circuit** — Hardware for signed and unsigned addition is identical","**Same subtraction circuit** — Subtraction is just addition with negated operand","**Simple negation** — Flip bits and add 1 (or equivalently, invert and add 1)","**Natural wraparound** — Overflow behavior is consistent and predictable","**Sign extension works** — To widen a signed value, replicate the sign bit"],"title":{"icon":"CheckCircle","text":"Properties of Two's Complement","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"}],"titleType":"number","titleNumber":5},{"id":"range-comparison","title":"Range Comparison: Signed vs Unsigned","content":[{"data":{"content":"The choice between signed and unsigned affects the *range* of representable values. Both use the same number of bits, but they *interpret* those bits differently."},"type":"text"},{"data":{"rows":[["8 bits","0 to 255","-128 to 127"],["16 bits","0 to 65,535","-32,768 to 32,767"],["32 bits","0 to ~4.3 billion","~-2.1 billion to ~2.1 billion"],["64 bits","0 to ~18.4 quintillion","~-9.2 quintillion to ~9.2 quintillion"]],"caption":"Signed vs Unsigned Ranges by Bit Width","headers":["Bit Width","Unsigned Range","Signed Range"]},"type":"table"},{"data":{"content":"**General formulas:**\n\nFor *n* bits:"},"type":"text"},{"data":{"rows":[["Unsigned","0","$$2^n - 1$"],["Signed","$$-2^{n-1}$","$$2^{n-1} - 1$"]],"headers":["Type","Minimum","Maximum"]},"type":"table"},{"data":{"content":"**The asymmetry in signed ranges:**\n\nNotice that signed ranges have one more negative value than positive. For 8-bit signed: -128 to +127 (not -127 to +127). This is because zero takes one of the \"non-negative\" patterns, leaving one extra pattern for negatives.\n\nThis asymmetry matters: you cannot negate the minimum signed value within the same type. In 8-bit signed, `-(-128)` cannot be represented as +128 because +128 exceeds the maximum (+127). In most systems, `-(-128) = -128` due to overflow—a subtle source of bugs."},"type":"text"},{"data":{"icon":"AlertCircle","title":"The Negation Overflow Trap","content":"In two's complement: `INT_MIN == -INT_MIN` due to overflow. This violates the mathematical expectation that negating a negative number yields a positive number. This edge case causes bugs in code that assumes `abs(x)` is always positive—for `INT_MIN`, it remains negative!","variant":"warning"},"type":"callout"},{"data":{"code":"#include \n#include \n#include \n\nint main() {\n int x = INT_MIN; // Minimum 32-bit signed integer: -2,147,483,648\n \n printf(\"x = %d\n\", x);\n printf(\"-x = %d\n\", -x); // Still -2,147,483,648 due to overflow!\n printf(\"abs(x) = %d\n\", abs(x)); // Also still negative!\n \n // This code has undefined behavior in C, but most systems exhibit this\n // The \"correct\" result (+2,147,483,648) cannot fit in 32-bit signed int\n \n // If you need absolute value that handles INT_MIN:\n long long safe_abs = (x == INT_MIN) ? -(long long)x : (x < 0 ? -x : x);\n printf(\"safe absolute value: %lld\n\", safe_abs); // 2,147,483,648\n \n return 0;\n}","fileName":"negation_trap.c","languages":[{"label":"C","value":"c"}],"showLineNumbers":true},"type":"code"}],"titleType":"number","titleNumber":6},{"id":"practical-implications","title":"Practical Implications in Real Code","content":[{"data":{"content":"The signed/unsigned distinction affects how operations behave, often in subtle ways that cause bugs."},"type":"text"},{"data":{"left":[{"data":{"items":["**Comparison bugs:** Comparing signed and unsigned values promotes signed to unsigned, producing unexpected results with negative values","**Loop underflow:** `for (unsigned i = n-1; i >= 0; i--)` is an infinite loop because unsigned values are always ≥ 0","**Subtraction underflow:** `unsigned size = 0; size - 1` produces maximum unsigned value, not -1","**Array indexing:** Using signed results as array indices without checking negativity"],"title":{"icon":"XCircle","text":"Common Signed/Unsigned Bugs","type":"icon","color":"destructive","variant":"outline-circle"},"variant":"accent"},"type":"list"}],"right":[{"data":{"items":["**Prefer signed for arithmetic:** Most general calculations benefit from signed types to handle intermediate negative values","**Use unsigned for bit manipulation:** When treating integers as bit patterns, unsigned provides cleaner semantics","**Be explicit in comparisons:** Cast explicitly when comparing signed and unsigned to document intent","**Avoid mixing types:** Keep operations homogeneous to avoid implicit conversions"],"title":{"icon":"CheckCircle","text":"Best Practices","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"}]},"type":"two-column"},{"data":{"code":"$64","fileName":"signed_unsigned_bugs.cpp","languages":[{"label":"C++","value":"cpp"}],"showLineNumbers":true},"type":"code"}],"titleType":"number","titleNumber":7},{"id":"when-to-choose","title":"When to Choose Signed vs Unsigned","content":[{"data":{"content":"The choice between signed and unsigned is not automatic. Different contexts have different correct choices."},"type":"text"},{"data":{"rows":[["General arithmetic","Signed","Handles intermediate negative results naturally"],["Loop counters","Signed (usually)","Prevents underflow bugs in decrementing loops"],["Array/container sizes","Unsigned (size_t)","Convention; sizes are inherently non-negative"],["Bit manipulation","Unsigned","Bit shifts and masks have cleaner semantics"],["Cryptography","Unsigned","Operations should wrap predictably; no undefined behavior"],["Hardware registers","Unsigned","Matches hardware's view of bit patterns"],["Database IDs","Unsigned*","Typically positive; larger range may be beneficial"],["Coordinates (x, y)","Signed","Negative coordinates are meaningful"],["Temperature values","Signed","Temperatures can be negative"],["File offsets","Signed (off_t)","Allows negative seeks relative to current position"]],"caption":"Decision Guide: Signed vs Unsigned","headers":["Scenario","Recommended Type","Rationale"]},"type":"table"},{"data":{"icon":"Info","title":"Language Conventions Vary","content":"Different languages have different conventions. C++ uses `size_t` (unsigned) for container sizes, while Java uses `int` (signed) for array lengths. Rust distinguishes carefully with `usize` and `isize`. Understanding your language's conventions prevents friction with standard libraries.","variant":"note"},"type":"callout"},{"data":{"content":"**The C++ Core Guidelines perspective:**\n\nThe C++ Core Guidelines (maintained by Bjarne Stroustrup and Herb Sutter) recommend:\n\n> \"Prefer `int` for most integers. Use unsigned only for bit manipulation and when you need modular arithmetic.\"\n\nThis might seem counterintuitive—shouldn't we use unsigned for sizes and counts that \"can't be negative\"? The argument against is that the bugs from signed/unsigned mixing, comparisons, and underflow often outweigh the benefit of the slightly larger positive range.\n\n**The counter-argument:**\n\nOthers argue that type systems should encode semantic constraints. If a value *cannot* be negative, declaring it unsigned provides:\n1. Self-documentation of intent\n2. Compiler warnings if negative values are assigned\n3. Compatibility with APIs that expect unsigned types\n\nThe debate continues, but being aware of it helps you make informed decisions."},"type":"text"}],"titleType":"number","titleNumber":8},{"id":"summary","title":"Summary: Signed vs Unsigned Integers","content":[{"data":{"content":"We've covered substantial ground on one of the most fundamental concepts in computer representation of numbers. Let's consolidate:"},"type":"text"},{"data":{"type":"ordered","items":["**Binary naturally represents non-negative values** — Special encoding is required for negative numbers","**Two's complement is the universal standard** — It enables signed and unsigned to share the same addition hardware","**The MSB acts as a sign indicator** — But also contributes a negative weight to the value","**Ranges differ by interpretation** — Same bits, different ranges: 0 to 255 or -128 to 127 for 8 bits","**Mixing signed and unsigned causes bugs** — Implicit conversions often produce surprising results","**Choose types thoughtfully** — Consider the domain: arithmetic favors signed; bit manipulation favors unsigned","**Negation of minimum value overflows** — `-INT_MIN == INT_MIN` is a critical edge case"],"title":{"icon":"CheckCircle","text":"Key Takeaways","type":"icon","color":"primary","variant":"outline-circle"},"variant":"accent"},"type":"list"},{"data":{"content":"**What's next:**\n\nWith the signed/unsigned distinction understood, we'll explore the *ranges* of integers in more depth—examining exactly how overflow occurs and what happens when calculations exceed representable bounds. This is where bugs silently creep into production systems."},"type":"text"},{"data":{"icon":"CheckCircle","title":"Page Complete","content":"You now understand the fundamental distinction between signed and unsigned integers. This knowledge forms the foundation for understanding integer overflow, fixed-size storage, and the cost model of integer operations—topics we'll explore in subsequent pages.","variant":"success"},"type":"callout"}],"titleType":"number","titleNumber":9}],"isLocked":false},{"id":"seed_997da6807d345a52e7393f00b17fe06a","title":"Range of Integers and Overflow","order":1,"content":null,"isLocked":true},{"id":"seed_a22d6bdcc1ec34501932dc08d149104b","title":"Fixed-Size Storage (32-bit, 64-bit intuition)","order":2,"content":null,"isLocked":true},{"id":"seed_8857727ed6e92039dc05dcd63e01e294","title":"Common Integer Operations and Their Cost Model","order":3,"content":null,"isLocked":true},{"id":"seed_79041b8d62f5a603e78f10f7a43193a7","title":"Integer Overflow and Real-World Bugs","order":4,"content":null,"isLocked":true}]}},"dataUpdateCount":1,"dataUpdatedAt":1792289445454,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["learningContent","getModule"],{"input":{"slug":"integer-data-types"},"type":"query"}],"queryHash":"[[\"learningContent\",\"getModule\"],{\"input\":{\"slug\":\"integer-data-types\"},\"type\":\"query\"}]"},{"dehydratedAt":1792289445801,"state":{"data":{"json":null},"dataUpdateCount":1,"dataUpdatedAt":1792289445452,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["learningContent","getProgress"],{"input":{"moduleId":"seed_983ae09389fbbd14ed4e363e13915b80"},"type":"query"}],"queryHash":"[[\"learningContent\",\"getProgress\"],{\"input\":{\"moduleId\":\"seed_983ae09389fbbd14ed4e363e13915b80\"},\"type\":\"query\"}]"},{"dehydratedAt":1792289445801,"state":{"data":{"json":null},"dataUpdateCount":1,"dataUpdatedAt":1792289445452,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["feedback","get"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_997da6807d345a52e7393f00b17fe06a"},"type":"query"}],"queryHash":"[[\"feedback\",\"get\"],{\"input\":{\"contentId\":\"seed_997da6807d345a52e7393f00b17fe06a\",\"contentType\":\"LEARNING_PAGE\"},\"type\":\"query\"}]"},{"dehydratedAt":1792289445801,"state":{"data":{"json":null},"dataUpdateCount":1,"dataUpdatedAt":1792289445452,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["feedback","getUserLike"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_997da6807d345a52e7393f00b17fe06a"},"type":"query"}],"queryHash":"[[\"feedback\",\"getUserLike\"],{\"input\":{\"contentId\":\"seed_997da6807d345a52e7393f00b17fe06a\",\"contentType\":\"LEARNING_PAGE\"},\"type\":\"query\"}]"},{"dehydratedAt":1792289445801,"state":{"data":{"json":[]},"dataUpdateCount":1,"dataUpdatedAt":1792289445452,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"success","fetchStatus":"idle"},"queryKey":[["highlights","getHighlights"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_997da6807d345a52e7393f00b17fe06a"},"type":"query"}],"queryHash":"[[\"highlights\",\"getHighlights\"],{\"input\":{\"contentId\":\"seed_997da6807d345a52e7393f00b17fe06a\",\"contentType\":\"LEARNING_PAGE\"},\"type\":\"query\"}]"},{"dehydratedAt":1792289445801,"state":{"data":"$undefined","dataUpdateCount":0,"dataUpdatedAt":0,"error":null,"errorUpdateCount":0,"errorUpdatedAt":0,"fetchFailureCount":0,"fetchFailureReason":null,"fetchMeta":null,"isInvalidated":false,"status":"pending","fetchStatus":"fetching"},"queryKey":[["highlights","getPopularHighlights"],{"input":{"contentType":"LEARNING_PAGE","contentId":"seed_997da6807d345a52e7393f00b17fe06a","minCount":2},"type":"query"}],"queryHash":"[[\"highlights\",\"getPopularHighlights\"],{\"input\":{\"contentId\":\"seed_997da6807d345a52e7393f00b17fe06a\",\"contentType\":\"LEARNING_PAGE\",\"minCount\":2},\"type\":\"query\"}]","promise":"$@65"}]},"children":"$L66"}]