cs50 section: week 4 kenny yu. announcements problem set 4 walkthrough online problem set 2...

CS50 SECTION: WEEK 4

Kenny Yu

Announcements

Problem Set 4 Walkthrough online Problem Set 2 Feedback has been sent out CORRECTION: Expect all future problem set feedback before

Thursday. Quiz 0 on Wed 10/12; details announced in lecture this week

Previous year’s quizzes are available: http://www.cs50.net/quizzes/

Section resources: https://cloud.cs50.net/~kennyyu/section/week4/

Section feedback poll: https://www.google.com/moderator/#15/e=a9fce&t=a9fce.4

4 What do you want to review in section for Quiz 0 next week?

https://www.google.com/moderator/#15/e=a9fce&t=a9fce.45

Agenda

1. RAM2. Pointers

1. Declaring Pointers2. Address Operator3. Dereferencing Pointers4. Pointer Assignment5. WARNING

3. Arrays Revisited4. Heap and Stack5. Malloc

RAM (Random Access Memory) “Active” memory Imagine RAM as being a very very big

array (on a 4GB RAM machine, you have 2^32 buckets)

Each address represents one byte in memory.

RAM (hex)

…0A 05 FF 00

Address (dec): 508 509 510 511

…

RAM (Random Access Memory) Whenever you declare a variable, space

is allocated for it in RAM. The location of the variable in RAM is the variable’s address.

RAM (hex)

…61 05 FF 00

Address: 508 509 510 511

…

char c = ‘a’;

c

Address of c is 508.

Pointers

Pointers are variables that store addresses.

Pointer(value =

address of Variable)

Pointer(value =

address of Variable)

Variable(value = 5)

Variable(value = 5)

RAM (Random Access Memory)

Pointer Syntax > Declaring Pointers Declaring a pointer:

var_type* pointer_name;

Example: int* ptr; // ptr has type int*;

// ptr points to int types

Pointer Syntax > Address Operator The & operator returns the address of a

variable (the memory location of the variable in RAM, it is actually just an integer)

Example: int x = 5; // declare and assign x’s value to 5int* ptr; // declare a pointer to int typesptr = &x; // ptr’s value is the address of x

(i.e. when ptr is dereferenced, it will return the value of x, which is 5)

Pointer Syntax > Dereferencing When we dereference a pointer, we

retrieve the value of the variable at the address stored by the pointer. We dereference a pointer by using the *

operator Example:

int x = 5; // declare and assign x to 5int* ptr; // declare a pointer to int typesptr = &x; // ptr contains the address of x int y = *ptr; // declare y and assign it to the value pointed by ptr. Now y and x are both 5.

Pointer Syntax > Assignment We can also change the value at the

address pointed to by a pointer, using the * operator on the left side of an assignment

Example: int x = 5; // declare and assign x to 5

int* ptr; // declare a pointer to int typesptr = &x; // ptr contains the address of x *ptr = 6; // change the value pointed to by ptr

Now x is equal to 6, and if we dereference ptr, that will also return 6.

Putting it all together

int x = 5; // declare and assign x to 5


xType: int

Address: 56789Value: 5

xType: int




int *ptr; // declare a pointer to int types

xType: int


xType: int



ptrType: int *

Address: 12345Value:

GARBAGE

ptrType: int *


GARBAGE




ptr = &x; // ptr contains the address of x

xType: int


xType: int



ptrType: int *


ptrType: int *






int y = *ptr; // declare y and dereference ptr. We have two copies of 5.

xType: int


xType: int



ptrType: int *


ptrType: int *


yType: int


yType: int






int y = *ptr; // declare y and dereference ptr. We have two copies of 6.

*ptr = 6; // change the value pointed to by ptr. x is now 6, y is still 5

xType: int


xType: int



ptrType: int *


ptrType: int *


yType: int


yType: int


A note on style

I’ve been typing this: int* ptr;

But most people program like this: int *ptr;

These are exactly the same! Just remember that you should interpret both of these as (int *) ptr; // ptr’s type is int* ( a pointer to

an int )

WARNING > * syntax

Do not confuse the * syntax!!!!!!1. Declarations: * is part of the type of the

pointerint* ptr; // ptr has type (int *). This is equivalent to: int* ptr;

2. Dereferencing: retrieves the value at the address that the pointer points to (i.e. follow the arrow)int x = 5;ptr = &x; // ptr points to xint y = *ptr; // dereference operator, y == 5 now

3. Assignment: changes the value at the address that the pointer points to*ptr = 6; // change the value of x; if ptr is dereferenced now, it will return 6. y is still 5

WARNING > Uninitialized Pointersint *ptr; // ptr not yet initialized// ptr = &x; initializes it.

GARBAGE? Huh? Pointers that have not yet been assigned an

address (i.e. ptr = &x) will point to a random place in RAM. Dereferencing an uninitialized pointer is a BIG NONO.

The operating system will not let you read/write to memory that you are not allowed to touch; this leads to Segmentation Faults.

TIP: Always initialize a pointer before dereferencing it

ptrType: int *


GARBAGE

ptrType: int *


GARBAGE

NULL

C has a sentinel address called NULL which is memory address 0 Used to signal to programmers that the

pointer is currently not set Useful in building linkedlists, binary search trees,

etc. Note: Pointers are NOT automatically

initialized to the value NULL WARNING Dereferencing a pointer pointing

to NULL leads to a segmentation fault

NULL

int *ptr = NULL; // declare ptr and set it to NULL

...

if (!ptr) { // !ptr evaluates to true if ptr == 0 (NULL)

printf(“ptr is pointing to nothing!\n”);

int pointee = *ptr; // try to dereference ptr: THIS WILL

// CAUSE A SEGMENTATION FAULT

} else {

printf(“ptr is pointing to address %d\n”,ptr);

int pointee = *ptr;

printf(“the value pointed to by ptr is %d\n,pointee);

}

NULL vs. ‘\0’

NULL is a sentinel memory address; NULL == 0 Used to indicate a pointer is pointing to

nothing ‘\0’ is a character who’s ASCII value is 0

Used to indicate the end of a string

NULL is an ADDRESS (a fake one)‘\0’ is a VALUE (a character)

Pointer Practice

a b c pa pb pc

a = b * c;

a *= c;

b = *pa;

pc = pa;

*pb = b * c;

c = (*pa) * (*pc);

*pc = a * (*pb);

int a = 3, b = 4, c = 5;int *pa = &a, *pb = &b, *pc = &c;

Pointer Practice

a b c pa pb pc

a = b * c; 20 4 5 &a &b &c

a *= c;

b = *pa;

pc = pa;

*pb = b * c;

c = (*pa) * (*pc);

*pc = a * (*pb);


Pointer Practice

a b c pa pb pc

a = b * c; 20 4 5 &a &b &c

a *= c; 100 4 5 &a &b &c

b = *pa;

pc = pa;

*pb = b * c;

c = (*pa) * (*pc);

*pc = a * (*pb);


Pointer Practice

a b c pa pb pc

a = b * c; 20 4 5 &a &b &c

a *= c; 100 4 5 &a &b &c

b = *pa; 100 100 5 &a &b &c

pc = pa;

*pb = b * c;

c = (*pa) * (*pc);

*pc = a * (*pb);


Pointer Practice

a b c pa pb pc

a = b * c; 20 4 5 &a &b &c

a *= c; 100 4 5 &a &b &c

b = *pa; 100 100 5 &a &b &c

pc = pa; 100 100 5 &a &b &a

*pb = b * c;

c = (*pa) * (*pc);

*pc = a * (*pb);


Pointer Practice

a b c pa pb pc

a = b * c; 20 4 5 &a &b &c

a *= c; 100 4 5 &a &b &c

b = *pa; 100 100 5 &a &b &c

pc = pa; 100 100 5 &a &b &a

*pb = b * c; 100 500 5 &a &b &a

c = (*pa) * (*pc);

*pc = a * (*pb);


Pointer Practice

a b c pa pb pc

a = b * c; 20 4 5 &a &b &c

a *= c; 100 4 5 &a &b &c

b = *pa; 100 100 5 &a &b &c

pc = pa; 100 100 5 &a &b &a

*pb = b * c; 100 500 5 &a &b &a

c = (*pa) * (*pc);

100 500 10000 &a &b &a

*pc = a * (*pb);


Pointer Practice

a b c pa pb pc

a = b * c; 20 4 5 &a &b &c

a *= c; 100 4 5 &a &b &c

b = *pa; 100 100 5 &a &b &c

pc = pa; 100 100 5 &a &b &a

*pb = b * c; 100 500 5 &a &b &a

c = (*pa) * (*pc);

100 500 10000 &a &b &a

*pc = a * (*pb);

50000 500 10000 &a &b &a


Pointer Arithmetic

int x = 5;int *ptr = &x;int y = *ptr; // y gets 5int z = *(ptr + 1); // z gets the stuff (?) in memory at address &x + 1 * sizeof(int)Could potentially segfault! So don’t use

pointer arithmetic unless you know something you allocated is there.

Pointer Arithmetic

int *ptr = &x;What are these addresses?ptr + 2 ==ptr + 0 ==ptr + 13 ==

Pointer Arithmetic

int *ptr = &x;What are these addresses?ptr + 2 == &x + 2 * sizeof(int)ptr + 0 == &xptr + 13 == &x + 13 * sizeof(int)

We need to multiply the offset by the size of the type the pointer is pointing to (for int *, we multiply by sizeof(int) )

Arrays are pointers

int scores[3] = {100, 99, 98}; score is actually a pointer to it’s first

element, score[0] == 100

int second = scores[2]; EXACTLY THE SAME AS: int second =

*(scores + 2); int zeroth = scores[0];

EXACTLY THE SAME AS: int zeroth = *scores;

Why does string == char * ? http://cdn.cs50.net/2011/fall/lectures/4/s

rc/cs50.hIn cs50.h:

...

/*

* Our own data type for string variables

*/

typedef char *string;

...

Strings

We alias string to be really a char *, a pointer to a character

Arrays are really just pointers So a string is really just a pointer to the

first character in a sequence of contiguous characters, terminated with ‘\0’

Strings

char *s = GetString(); // user enters “cat”GetString() returns a pointer to the first

character of a char array in memory.

Type: charAddress: 56789

Value: ‘c’


Value: ‘c’


sType: char *

Address: 12345

Value: 56789

sType: char *

Address: 12345

Value: 56789Type: charAddress: 56790

Value: ‘a’


Value: ‘a’


Value: ‘t’


Value: ‘t’


Value: ‘\0’


Value: ‘\0’

Strings

QUESTION:

But wait, where is the space being allocated for the string?

Heap and Stack

Heap

•Contains local variables.•Function calls create new ‘frames’ on the stack.

Memory belonging to process.

Stack

Lower Memory Addresses

Higher Memory Addresses

•Contains global variables.•Dynamically allocated memory reserved on heap.

Heap and Stack

Heap

In main:

// user enters “cat”char *s = GetString();

Memory belonging to process.

Stack

Lower Memory Addresses

Higher Memory Addresses

Space is dynamicallyallocated for “cat” in the heap

ss

‘c’‘c’

‘a’‘a’

‘t’‘t’

‘\0’‘\0’

Heap vs. Stack

Heap memory persists Memory allocated in the heap by one

function will still be there after the function return (unless the memory is freed)

Stack memory does not persist Memory allocated in the stack (with stack

frames, e.g. local variables) by a function will not persist after the function returns

Dynamically allocating memory malloc(int size) : memory allocation

On the terminal, type “man 3 malloc” takes an integer parameter and returns a

pointer to an array in the heap of the requested size, or returns NULL to signal a failure occurred

This won’t work

int arrsize = GetInt();int arr[arrsize];

GCC must know at compile time the size of arrays, but arrsize is computed at runtime through user input.

=> Can’t allocate variable-sized arrays!

A fix:

int arrsize = GetInt();int *arr = (int *) malloc(sizeof(int) * arrsize);

malloc returns a pointer to an int array of size arrsize. This array will be located in the heap.

=> Can allocate memory dynamically with malloc!

Should make sure malloc workedint arrsize = GetInt();int *arr = (int *) malloc(sizeof(int) * arrsize);if (arr == NULL) { printf(“malloc failed! No memory left!\n”);}

Malloc will return NULL if it fails to allocate the requested amount of memory.

Malloc’ed memory must be freed! ALL memory allocated by malloc MUST be freed

Otherwise this will lead to memory leaks – VERY BAD!

Have you ever wondered why your computer seems to slow down even if you have no programs open?

Use the free(ptr) function; ptr must be a pointer returned by a malloc call!

int arrsize = GetInt();

int *arr = (int *) malloc(sizeof(int) * arrsize);

if (arr == NULL)

return -1;

// do some stuff

free(arr);

GetString()

GetString() calls malloc to allocate the memory in the heap for the string

So every time you called GetString() and didn’t free the memory, you created a memory leak!!!!

From now on, you must free all your strings.char *s = GetString();// do stufffree(s);

Swap

int main(void) {

int x = 5;

int y = 6;

swap(x,y);

printf(“x: %d, y: %d\n”, x, y); // what are x and y after swap?

}

void swap(int a, int b) {

int temp = a;

a = b;

b = temp;

}

Swap

int main(void) {

int x = 5;

int y = 6;

swap(x,y);

printf(“x: %d, y: %d\n”, x, y); // x = 5, y = 6, WHAT??!

}


int temp = a;

a = b;

b = temp;

}

Swap: Stack frames

int main(void) {

int x = 5;

int y = 6;

swap(x,y);

printf(“x: %d, y: %d\n”, x, y);

}


int temp = a;

a = b;

b = temp;

}

main

swap

x = 5x = 5 y = 6y = 6

a = 5a = 5 b = 6b = 6

Swap has it’s own copies of 5 and 6!!You cannot change x and y inside swap.

Swap: Stack frames

int main(void) {

int x = 5;

int y = 6;

swap(x,y);


}


int temp = a;

a = b;

b = temp;

}

main

swap

x = 5x = 5 y = 6y = 6

a = 5a = 5 b = 6b = 6

Swap has it’s own copies of 5 and 6!!You cannot change x and y inside swap.

This is an example of call-by-value: the values of the parameters are copied fromthe caller into the callee.

Swap: fix

int main(void) {

int x = 5;

int y = 6;

swap(&x,&y);

printf(“x: %d, y: %d\n”, x, y); // x = 6, y = 5

}

void swap(int *a, int *b) { // a and b are pointers

int temp = *a; // temp gets the old value at the address in a

*a = *b; // assign the address in a to the value at the

// address in b

*b = temp; // assign the address in b to temp

}

Swap: Stack frames

int main(void) {

int x = 5;

int y = 6;

swap(&x,&y);


}

void swap(int *a, int *b) {

int temp = *a;

*a = *b;

*b = temp;

}

main

swap

x = 5x = 5 y = 6y = 6

a = &xa = &x b = &yb = &y

Swap: Stack frames

int main(void) {

int x = 5;

int y = 6;

swap(&x,&y);


}


int temp = *a;

*a = *b;

*b = temp;

}

main

swap

x = 5x = 5 y = 6y = 6

aa bb

temp = 5

temp = 5

a = &xa = &x b = &yb = &y

Swap: Stack frames

int main(void) {

int x = 5;

int y = 6;

swap(&x,&y);


}


int temp = *a;

*a = *b;

*b = temp;

}

main

swap

x = 6x = 6 y = 6y = 6

aa bb

temp = 5

temp = 5

a = &xa = &x b = &yb = &y

Swap: Stack frames

int main(void) {

int x = 5;

int y = 6;

swap(&x,&y);


}


int temp = *a;

*a = *b;

*b = temp;

}

main

swap

x = 6x = 6 y = 5y = 5

aa bb

temp = 5

temp = 5

a = &xa = &x b = &yb = &y

int main(void) {

int x = 5;

int y = 6;

swap(&x,&y);


}


int temp = *a;

*a = *b;

*b = temp;

}

Swap: Stack frames

main

swap

x = 6x = 6 y = 5y = 5

temp = 5

b = &y

a = &x

int main(void) {

int x = 5;

int y = 6;

swap(&x,&y);


}


int temp = *a;

*a = *b;

*b = temp;

}

Swap: Stack frames

main

swap

x = 6x = 6 y = 5y = 5

temp = 5

This is a call-by-reference: instead of passing in a value, we pass a pointerso that the callee can read/write to the given address in the pointer.

b = &y

a = &x

So why use pointers?

Pointers allow us to dynamically allocate memory With malloc Must be freed Can allocate variables in heap to be

preserved between function calls Pointers allow us to call by reference

Allows us to pass pointers into arguments and affect variables through multiple functions

Swap function

Fun fun fun

https://cloud.cs50.net/~kennyyu/section/week4/week4.c

cs50 section: week 4 kenny yu. announcements problem set 4 walkthrough online problem set 2...

Documents