0% found this document useful (0 votes)

5 views116 pages

Low level programming Lecture2

This document is a lecture outline for CS 107 at Stanford University, focusing on integer representations, bits, and bytes. It covers topics such as numerical bases, binary and hexadecimal representations, data sizes, and integer overflow in C. Additionally, it includes information about assignments, lab signups, and humorous binary anecdotes.

Uploaded by

Ashish Dhiwar

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

5 views116 pages

Low level programming Lecture2

Uploaded by

Ashish Dhiwar

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PDF, TXT or read online on Scribd

You are on page 1/ 116

CS 107

Lecture 2: Integer
Representations and
Bits / Bytes

Computer Systems
Summer 2025
Stanford University

Computer Science Department

Reading:
Reader: Bits and Bytes
Textbook: Chapter 2.2

This document is copyright (C) Stanford Computer Science, Adam Keppler, and Olayinka Adekola licensed under Creative Commons Attribution 2.5 License. All rights reserved.
Based on slides created by Joel Ramirez, Nick Troccoli, Chris Gregg
Some Binary Humor (It is Either Funny or Not)

If you get an 11/100 on a CS test, but you claim it should be counted as a 'C', they'll probably decide you
deserve the upgrade. - https://xkcd.com/953/ 2
Assignment 0: Unix!
Assignment page: https://web.stanford.edu/class/cs107/assign0/
Assignment already released, due Friday, 6/27

Late submissions accepted till Sunday 6/29

3
Lab
Signup
https://web.stanford.edu/class/archive/cs/cs107/cs107.1258/cgi-bin/lab_preferences

Labs will begin tomorrow, please make sure to fill out the
preference form.

4
Today's Topics
• Numerical Bases
• Binary, Bits, & Bytes
• Octal & Hexadecimal Bases
• ASCII & Characters

• Integer Representations
• Unsigned Numbers
• Signed Numbers
• Two’s Complement
• Two’s Complement Overflow
• Signed vs Unsigned Number Casting in C
• Signed and Unsigned Comparisons

• Data Sizes & The sizeof Operator

• Min and Max Integer Values
• Truncating Integers
• More on Extending the Bit representation of Numbers
• Addressing and Byte Ordering
• Boolean Algebra
5
Combinations of bits can Encode Anything
represent everything

We can encode anything

we want with bits. E.g., the
ASCII character set.

6
Number Representations
• Unsigned Integers: positive and 0 integers. (e.g. 0, 1, 2, … 99999…
• Signed Integers: negative, positive and 0 integers. (e.g. …-2, -1, 0, 1,… 9999…)

• Floating Point Numbers: real numbers. (e,g. 0.1, -12.2, 1.5x1012)

Look up IEEE floating point if you’re interested ☺ !

7
Data Sizes

On the myth computers (and

most 64-bit computers today),
the int representation is
comprised of 32-bits, or four 8-
bit bytes. NOTE: C language
does not mandate sizes. To the
right is Figure 2.3 from your
textbook:

8
Data Sizes

There are guarantees on the

lower-bounds for type sizes, but
you should expect that the myth
machines will have the numbers
in the 64-bit column.

9
Data Sizes

You can be guaranteed the sizes

for int32_t (4 bytes) and
int64_t (8 bytes)

10
Data Sizes
C allows a variety of ways to
order keywords to define a type.
The following all have the same
meaning:

unsigned long
unsigned long int
long unsigned
long unsigned int

11
Transitioning To Larger Datatypes

• Early 2000s: most computers were 32-bit. This means that pointers were 4
bytes (32 bits).
• 32-bit pointers store a memory address from 0 to 232-1, equaling 232 bytes of
addressable memory. This equals 4 Gigabytes, meaning that 32-bit
computers could have at most 4GB of memory (RAM)!
• Because of this, computers transitioned to 64-bit. This means that datatypes
were enlarged; pointers in programs were now 64 bits.
• 64-bit pointers store a memory address from 0 to 264-1, equaling 264 bytes of
addressable memory. This equals 16 Exabytes, meaning that 64-bit
computers could have at most 1024*1024*1024*16 GB of memory (RAM)! 12
Addressing and Byte Ordering

On the myth machines, pointers are 64-bits long, meaning that a program can "address" up to 264 bytes of memory,
because each byte is individually addressable.

This is a lot of memory! It is 16 exabytes, or 1.84 x 1019 bytes. Older, 32-bit machines could only address 232 bytes, or 4
Gigabytes.

64-bit machines can address 4 billion times more memory than 32-bit machines...

Machines will not need to address more than 264 bytes of memory for a long, long time.

13
Overflow
• If you exceed the maximum value of your bit representation, you wrap around
or overflow back to the smallest bit representation.

0b1111 + 0b1 = 0b0000

• If you go below the minimum value of your bit representation, you wrap
around or overflow back to the largest bit representation.

0b0000 - 0b1 = 0b1111

14
Overflow in Unsigned Addition
When integer operations overflow in C, the runtime does not produce an error:
#include<stdio.h>
#include<stdlib.h>
#include<limits.h> // for UINT_MAX
$ ./unsigned_overflow
a = 4294967295
int main() {
b = 1
unsigned int a = UINT_MAX;
a + b = 0
unsigned int b = 1;
unsigned int c = a + b;
printf("a = %u\n",a); Technically, unsigned integers in C don't
printf("b = %u\n",b); overflow, they just wrap. You need to be
printf("a + b = %u\n",c); aware of the size of your numbers. Here is
} return 0;
one way to test if an addition will fail:
// for addition
#include <limits.h>
unsigned int a = <something>;
unsigned int x = <something>;
if (a > UINT_MAX - x) /* `a + x` would overflow */;
15
Unsigned Integers
For positive (unsigned) integers, there is a 1-to-1 relationship between the decimal
representation of a number and its binary representation. If you have a 4-bit
number, there are 16 possible combinations, and the unsigned numbers go from 0
to 15:
0b0000 = 0 0b0001 = 1 0b0010 = 2 0b0011 = 3
0b0100 = 4 0b0101 = 5 0b0110 = 6 0b0111 = 7
0b1000 = 8 0b1001 = 9 0b1010 = 10 0b1011 = 11
0b1100 = 12 0b1101 = 13 0b1110 = 14 0b1111 = 15

The range of an unsigned number is 0 → 2w - 1, where w is the number of bits in

our integer. For example, a 32-bit int can represent numbers from 0 to 232 - 1,
or 0 to 4,294,967,295.
16
Unsigned Integers

17
Computers use a limited number of bits for numbers
#include<stdio.h>
#include<stdlib.h>

int main() {
int a = 200;
200 * 300 * 400 * 500 = 12,000,000,000
int b = 300;
int c = 400;
int d = 500;
int answer = a * b * c * d;
printf("%d\n",answer);
return 0;
}

$ gcc -g -O0 mult-test.c -o mult-test

$ ./mult-test
-884901888
$ 18
Computers use a limited number of bits for numbers
#include<stdio.h> Recall that in base 10, you can represent: 10
#include<stdlib.h> numbers with one digit (0 - 9),
100 numbers with two digits (00 - 99),
int main() { 1000 numbers with three digits (000 - 999)
int a = 200;
I.e., with n digits, you can represent up to 10n
int b = 300;
numbers.
int c = 400;
int d = 500; In base 2, you can represent:
int answer = a * b * c * d; 2 numbers with one digit (0 - 1)
printf("%d\n",answer); 4 numbers with two digits (00 - 11)
return 0; 8 numbers with three digits (000 - 111)
}
I.e., with n digits, you can represent up to 2n
numbers
The C int type is a "32-bit" number, meaning it uses 32 digits. That
means we can represent up to 232 numbers. 19
Computers use a limited number of bits for numbers
#include<stdio.h> 232 = 4,294,967,296
#include<stdlib.h> 200 * 300 * 400 * 500 = 12,000,000,000

int main() {
int a = 200;
int b = 300;
int c = 400;
int d = 500;

int answer = a * b * c * d;
printf("%d\n",answer);
return 0; Turns out it is worse -- ints are signed,
} meaning that the largest positive number is
(232 / 2) - 1 =
$ gcc -g -O0 mult-test.c -o mult-
test 231 - 1 = 2,147,483,647
$ ./mult-test
-884901888
$ 20
Computers use a limited number of bits for numbers
#include<stdio.h>
#include<stdlib.h>

int main() { The good news: all of the following produce

int a = 200;
the same (wrong) answer:
int b = 300;
int c = 400;
int d = 500; (500 * 400) * (300 * 200)

int answer = a * b * c * d; ((500 * 400) * 300) * 200

printf("%d\n",answer); ((200 * 500) * 300) * 400
return 0;
} 400 * (200 * (300 * 500))
$ gcc -g -O0 mult-test.c -o mult-
test
$ ./mult-test
-884901888
$ 21
Let's look at a different program
#include<stdio.h>
#include<stdlib.h>

int main() {
float a = 3.14;
float b = 1e20;

printf("(3.14 + 1e20) - 1e20 = %f\n", (a + b) - b);

printf("3.14 + (1e20 - 1e20) = %f\n", a + (b - b));

return 0;
}
$ gcc -g -Og -std=gnu99 float-mult-
test.c -o float-mult-test
$ ./float-mult-test.c
(3.14 + 1e20) - 1e20 = 0.000000
3.14 + (1e20 - 1e20) = 3.140000 bigger problem! 22
$
Information Storage

23
Information Storage

In C, everything can be thought of as a block of 8 bits

24
Information Storage

In C, everything can be thought of as a block of 8 bits

called a "byte"

25
Byte Range
Because a byte is made up of 8 bits, we can represent the range of a byte as
follows:

00000000 to 11111111

This range is 0 to 255 in decimal.

But, neither binary nor decimal is particularly convenient to write out bytes
(binary is too long, and decimal isn't numerically friendly for byte
representation)

So, we use "hexadecimal," (base 16).

26
Hexadecimal
• When working with bits, oftentimes we have large numbers with 32 or 64 bits.
• Instead, we’ll represent bits in base-16 instead; this is called hexadecimal.

0110 1010 0011

0-15 0-15 0-15

27
Hexadecimal
• Hexadecimal is base-16, so we need digits for 1-15. How do we do this?

0 1 2 3 4 5 6 7 8 9 a b c d e f
10 11 12 13 14 15

28
Hexadecimal
Hexadecimal has 16 digits, so we augment our normal 0-9 digits with six
more digits: A, B, C, D, E, and F.

Figure 2.2 in the textbook shows the hex digits and their binary and decimal
values:

29
Hexadecimal
• When working with bits, oftentimes we have large numbers with 32 or 64 bits.
• Instead, we’ll represent bits in base-16 instead; this is called hexadecimal.

6 A 3
0-15 0-15 0-15

Each is a base-16 digit!

30
Hexadecimal
• We distinguish hexadecimal numbers by prefixing them with 0x, and binary
numbers with 0b. These prefixes also work in C
• E.g. 0xf5 is 0b11110101

0x f 5
1111 0101

31
Practice: Hexadecimal to Binary
What is 0x173A in binary?

Hexadecimal 1 7 3 A
Binary 0001 0111 0011 1010

32
Practice: Hexadecimal to Binary
What is 0b1111001010 in hexadecimal? (Hint: start from the right)