PE0 Reminder

• Tomorrow (1 October, 6 - 9 PM)

• Report to your assigned laboratory by 6 PM

Midterm Reminder

• Next Monday (7 October, 4:30 - 6:15 PM)

• Report to MPSH 2B by 4:30 PM

Deadline Extensions

• Quiz 7: +1 Day due to PE0

• Exercise 3: +2 Days due to PE0 and Midterm

PE1

Covers until

• Unit 18 (today's lecture)

• Exercise 4

Variable

• A place in memory that holds one or more values

• Every variable has a name, a type, a value, and an address

• We can access a variable through its name or its memory address

Accessing a Variable Through Its Name

a = b;

Copy the value stored in memory location named b

into the memory location named a.

Address-of operator &

if x is the name of a variable, &x is its memory address.

Array Decay

long a[30];
long *addr = a;

a is just &a[0].

Pointer

A variable that stores a memory address (mostly of other variables)

long c;
long *addr;
addr = &c;

Accessing the Address of a Variable

a = &b;

Copy the address of the memory location named b

into the memory location named a.

Dereference operator *

if x is a pointer (a variable storing a memory address), *x is the content of that memory address.

not to be confused with the pointer type (e.g., long *) or multiplication (e.g., 2 * 3).

Changing variable via its address

Accessing a Variable Through Its Address

a = *b;

Copy the value stored in the memory location of which the address is stored in memory location named b

into the memory location named a.

Accessing a Variable Through Its Address

*a = b;

Copy the value stored in the memory location named b

into the memory location of which the address is stored in memory location named a

Common Bug

long *addr;
*addr = 15;

During execution, your code must access only

1. Memory on the allocated stack frames

Pointer Types

• if x as the type T, &x has the type T* (pointer to T / address of T)

• if x as the type T*, *x has the type T

Pointers must be of the same type

double p = 3.1415926;
long radius = 5;
double *addr;
addr = &p; // ok
addr = &radius; // not ok

(void * is special)

Pointer arithmetic

long x = 1;
long *ptr = &x;
ptr += 1;

Pointers are variables too

long x;
long *ptr = &x;
long **ptrptr = &ptr;

The NULL Pointer

A special pointer value that says a pointer points to "nothing".

Swap

void swap(long *a, long *b) {
  long temp = *a;
  *a = *b;
  *b = temp;
}
int main() {
  long a = 10;
  long b = -4;
  swap(&a, &b);
}

• Heap is another region of memory that a program can utilize

• Explicitly "borrows" memory space for use

• Must "return" the memory space after use

Why heap?

• Lifetime of content stored on heap can exceed the lifetime of the function that allocates it

• Size of heap is typically much larger than stack

How to borrow: malloc or calloc

void *malloc(size_t size);
void *calloc(size_t count, size_t size);

How to return: free

void free(void *);

During execution, your code must access only

1. Memory on the allocated stack frames
2. Memory on the heap that the code borrows but hasn't returned

Type size_t

• A unsigned integer type used for array index, amount of memory, size of types, etc.

Fixed-Size vs Dynamic Arrays

• Fixed-size arrays: size known in advanced (e.g., there are 10 digits, 12 months, etc.)

• Dynamic arrays: size known only during execution (e.g., number of students in a course)

Common Bug 1

size_t len = cs1010_read_size_t();
long *list = cs1010_read_long_array(len);
long max = find_max(list, len);
free(list);
list[0] = 0; // use after free

Common Bug 2

size_t len = cs1010_read_size_t();
long *list = malloc(sizeof(long) * len);
list = cs1010_read_long_array(len); // memory leak!
long max = find_max(list, len);
free(list);

String

• An array of char
• Terminated with the null character '\0'

char str[5] = { 'a', 'b', 'c', 'd', '\0' };

char str[5] = "abcd";

String Literals

Stored in read-only "text segment" in memory

char *str1 = "Hello";    // str1 points to read-only array
char str2[6] = "Hello";  // str2 points to array on stack
str1[0] = 'h'; // run-time error
str2[0] = 'h'; // ok

Summary of Important Rules

• Do not access memory space you are not allowed to.

• Always return memory space that you borrow.

Homework

• Exercise 3
• Problem Set 15-17
• Diagnostic Quiz 7