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’;

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)

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

ptrType: int *

Address: 12345Value:

GARBAGE

ptrType: int *

GARBAGE

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

xType: int

ptrType: int *

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

xType: int

ptrType: 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

ptrType: 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

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

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’

sType: char *

Address: 12345

Value: 56789

sType: char *

Address: 12345

Value: 56789Type: charAddress: 56790

Value: ‘a’

Value: ‘t’

Value: ‘\0’

Strings

QUESTION:

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

Heap and Stack

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

Memory belonging to process.

Lower Memory Addresses

Higher Memory Addresses

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

Heap and Stack

In main:

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

Memory belonging to process.

Lower Memory Addresses

Higher Memory Addresses

Space is dynamicallyallocated for “cat” in the heap

‘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);

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;

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;

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;

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;

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;

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

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;

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

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;

x = 6x = 6 y = 5y = 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

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

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

CS50 Appliance 2

Problem Set I Response - Massachusetts Institute of Technologypeople.csail.mit.edu/halordain/Digital Image Processing/Problem Set I... · Problem Set I Problem 1 – Quantization

Enzymes Problem Set

Problem Set 3

Internet - CS50

Security - CS50 CDN

This is CS50

CS50 WEEK 6 Kenny Yu. Announcements Problem Set 6 Walkthrough up Problem Set 4 [Sudoku] Returned Problem Set 5 [Bitmaps + Jpegs] to be returned

CS50 SECTION WEEK 9 Kenny Yu. Announcements Problem Set 6 Returned. Problem Set 8 Walkthrough up Final Project’s Proposal due 11am Monday 11/14

CS50 Beyond

CS50 SEMINARcdn.cs50.net/2015/fall/seminars/cloud9/cloud9.pdf · customizing cloud9 and the cs50 ide cs50 seminar dan armendariz danallan@cs.harvard.edu

HTML - CS50 CDN

CS50 Лекція 0-2

Problem Set 3: Breakout - cdn.cs50.netcdn.cs50.net/2014/fall/psets/3/pset3/pset3.pdfProblem Set 3: Breakout This is CS50. Harvard University. Fall 2014. ... Ultimately, confirm that

n if or - CS50 · 2020-03-04 · n if or - CS50 ... 6

CS50 SECTION WEEK 8 Kenny Yu. Announcements Problem Set 5 Returned. Problem Set 7 Walkthrough up Final Project’s Pre-proposal due 11am Monday 11/9

TM freezing blood components at any temperature. that you ... Freezing Bags… · 5 - 30 ml, "V6" Tubing Set, case of 6 sets CS50 CS50-3 CS50F4S CS50M3 CS50N CS50NS CS50NSW CS50S

CS50 concentration guide

7520 Problem Set

Problem Set 2