CS/COE 0449 (term 2174) Jarrett Billingsley C - Pointers CS/COE 0449 (term 2174) Jarrett Billingsley

Class announcements Project 1! Due at 11:59 PM on Sunday, February 5th Quiz 1 will be next Tuesday!! Yeah, that's right! Midterm 1 is in two weeks!!! Boy, you've got a lot of stuff to get ready for, huh? I really recommend you do the practice exercises in the book... The labs this week and next week will also give you more practice with C. 1/19/2017 CS/COE 0449 term 2174

Question time! 1/19/2017 CS/COE 0449 term 2174

Pointers 1/19/2017 CS/COE 0449 term 2174

Memory! Memory's a big array of bytes. Every byte has an address. The only way your computer can access any data in memory (all the variables etc) is by knowing their addresses. Say we had a variable int x and its address was DC04. How many bytes would it span? In a little-endian machine, what would its value be? (you're learning about endianness in 447, right?) 0xBEEFC0DE! Address Value ... DC0B 44 DC0A 4 DC09 2 DC08 88 DC07 BE DC06 EF DC05 C0 DC04 DE DC03 2A DC02 27 DC01 0E DC00 42 DC0D 8B DC0E BB 1/19/2017 CS/COE 0449 term 2174

You've kinda used pointers in Java... Remember writing linked lists? class Link { Link next; int value; } Link list = new Link(); list.next = new Link(); list.next.next = new Link(); Object references are really just pointers. So if you start getting confused, just think about how those work. next: value: 0 next: value: 0 next: value: 0 1/19/2017 CS/COE 0449 term 2174

int x = 0x100; int y = 0x200; int* px = &x; int* py = &y; Variables vs. Pointers A variable is a named piece of memory. A pointer is a variable that holds a memory address. int x = 0x100; int y = 0x200; int* px = &x; int* py = &y; Name Address Value py DC0C DC04 px DC08 DC00 y 0200 x 0100 1/19/2017 CS/COE 0449 term 2174

Declaring pointers In Java, you can make an array of any type by sticking brackets after it. int[], int[][], int[][][] etc. In C, you can make a pointer to any type by sticking stars after it. int*, int**, int*** etc. When you make a pointer, the type before the star is the type of value that it points to. So an int* can point to an int variable. 1/19/2017 CS/COE 0449 term 2174

The address-of operator When used as a prefix operator, & means "address of." It gives you the memory address of any variable, array item, etc. The address is given to you as a pointer type. Use it on an int? You get an int*. Let's try printing out addresses using the %p format specifier with printf! 1/19/2017 CS/COE 0449 term 2174

The address-of operator Coming back to this example... int x = 0x100; int y = 0x200; int* px = &x; int* py = &y; What value does &x give us? What type is &x? What value does &px give us? What type is &px? OHOHOHOHO Name Address Value py DC0C DC04 px DC08 DC00 y 0200 x 0100 1/19/2017 CS/COE 0449 term 2174

The dereference operator An address on its own isn't that useful... What's useful is being able to read and write the data at that address. When used as a prefix operator, * is the dereference operator. When you use it on a pointer, it's like you're directly using the variable that it points to. 1/19/2017 CS/COE 0449 term 2174

The dereference operator Okay: now let's see what happens when we dereference these pointers. int x = 0x100; int y = 0x200; int* px = &x; int* py = &y; *px = 0x300; printf("%x\n", x); printf("%x\n", *px); Name Address Value py DC0C DC04 px DC08 DC00 y 0200 x 0100 0300 1/19/2017 CS/COE 0449 term 2174

Watch out.. int x = 0x100; int* px = &x; px = 0x300; What does this program do? int x = 0x100; int* px = &x; px = 0x300; printf("%x\n", x); printf("%x\n", *px); Name Address Value px DC04 DC00 x 0100 0300 1/19/2017 CS/COE 0449 term 2174

Everyone on the same page? 1/19/2017 CS/COE 0449 term 2174

So what? 1/19/2017 CS/COE 0449 term 2174

Every problem in CS... ...can be solved with another level of indirection (pointers). Pointers are the basis of: Dynamic memory management Strings Arrays Object-oriented programming Pretty much everything your operating system does Everything... everything does. Understanding pointers is understanding how software works. 1/19/2017 CS/COE 0449 term 2174

Functions Functions are machines which grind up socks and gloves and turn them into numbers. ?????????????? Very important diagram from the book here. 1/19/2017 CS/COE 0449 term 2174

Passing by reference In Java, you're stuck returning at most one value unless you resort to ugly hacks like returning an Object[]. In C, you can use pointers to modify values given as parameters. Let's write a function that takes two pointers – one for hours and one for minutes – and increments the minutes by 1. If the minutes exceed 59, then they should reset to 0 and tick the hours up by 1. 1/19/2017 CS/COE 0449 term 2174

Arrays! 1/19/2017 CS/COE 0449 term 2174

No more beating around the bush I've been saying in C, arrays are Not A Thing. That's because... As far as C concerned, an array is just a pointer. Wat. char buffer[40]; printf("%p\n", buffer); // woah. 1/19/2017 CS/COE 0449 term 2174

What does the [] operator do? When you write array[i], what's happening? Well, let's use the address-of operator to help us see... 1/19/2017 CS/COE 0449 term 2174

Pointer arithmetic When you use the array indexing operator, you're really just adding an offset to the pointer, and using that as the address to access. In other words, a[i] is interchangeable with *(a + i). Wait, but— If a is a pointer, what does a + i mean? Let's print it out. 1/19/2017 CS/COE 0449 term 2174

Pointer arithmetic array[3] DC0C 0003 array[2] DC08 0002 array[1] DC04 If we write this: int array[] = {0, 1, 2, 3}; Memory looks like this: If we want to access array[2]... What is that equivalent to? *(array + 2) But look at the addresses. How big is each item in the array? When we write array + 2, it doesn't add 2 to the address. We don't get 0xDC02. It adds the size of 2 items to the address. We get 0xDC08. Name Address Value array[3] DC0C 0003 array[2] DC08 0002 array[1] DC04 0001 array[0] DC00 0000 1/19/2017 CS/COE 0449 term 2174

Arrays-of-arrays? Before we go, I will leave you with this: int main(int argc, char** argv) 1/19/2017 CS/COE 0449 term 2174