CS/COE 0449 Jarrett Billingsley C – Pointers and Arrays CS/COE 0449 Jarrett Billingsley

fgets(input, sizeof(input), stdin); // do stuff with input, it's fine, Class announcements project 1 due by this Saturday night! remember I have office hours Fridays 12-2 in 6509 SENSQ oh yeah: when getting input in a loop, you don't have to clear the input buffer char input[100]; while(1) { fgets(input, sizeof(input), stdin); // do stuff with input, it's fine, // you don't have to clear it out or // anything before the next loop } CS449

What are pointers? CS449

Memory! (déjà vu) memory is a big one-dimensional array of bytes every byte value has an address this is its "array index" addresses start at 0, like arrays in C/Java for values bigger than a byte, we use consecutive bytes the address of any value, regardless of size, is the address of the first byte (smallest address) here is an int variable what is its sizeof()? what is its address? what is its value? :^) Addr Val ... 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 - we often draw memory with the addresses increasing upwards – this will make more sense when we get to the stack - its sizeof() is 4 in this case - 4 bytes long - its address is 0xDC04 - its value could be either 0xDEC0EFBE (big-endian) or 0xC0DEBEEF (little-endian) CS449

5! x 5 Split personalities x variables are not the same thing as the values they hold this variable x holds 5 but x is, itself, "a thing" we can do things with the variable, not just the value it holds it's like a car the car can have a name you can put things in it the car is its own thing though 5 x 5! x CS449

&x x Pointy things a pointer is like the key to the car it's easy to hand the key around it's easy* to copy the key the key isn't the car but it lets you access the car and the things inside it and you can give the key to someone else but be careful who you give them to! &x x * stretching the metaphor a bit, but it's far easier to copy a key than it is to copy a car - you have to be careful when passing pointers around too, since someone might hang onto a copy of a pointer you didn't expect - and then they try to use it - and things go wrong CS449

Pointers in C CS449

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(); next: value: 0 next: value: 0 next: value: 0 what about a reference that doesn't refer to anything? C has null too, but you have to yell it: NULL! - if you don't remember linked lists, welllllllll project 2 is gonna have them :^) CS449

int[] int* int[][] int** Declaring pointers in Java, how do you declare an array of any type X? you put square brackets after the type: X[] int[] int* an array that holds ints. an pointer to an int. int[][] int** an array that holds arrays, and each of those holds ints. a pointer to a pointer, which points to an int. a C pointer can point to either a single value or an array of that type. - the meaning of the pointer – single value or array – depends on context. - really, non-array variables are just arrays of length 1… ;) - often, but not always, you can think of a pointer as pointing to an array of values… and a double-pointer is almost always a 2D array CS449

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 i.e. it "adds a star" I know it seems backwards, why wouldn't they make * add a star, or name pointers int& right? use it on an int? you get an int* use it on an int*? you get an int** YOU GET THE IDEA I hope you can use it on just about anything with a name &x &arr[10] &main (yep!) We'll talk about function pointers at a later date CS449

Pointers are variables too… 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 x DC00 0100 y DC04 0200 px DC08 DC00 py DC0C DC04 the addresses of these variables are given to us automatically by the compiler-ish since pointers are variables, can you get their addresses? - "ish" because when we learn about the stack, you'll see that the addresses of local variables can differ depending on where on the stack they are executing - but the compiler gives you the offsets of those variables from the stack pointer. - yes. yes, you can. CS449

Like a locker room, but without the awkward nudity every variable is a locker each locker has a number its address! and each locker has its contents its value! and one locker can hold the number of another locker a pointer! float 3.14 locker 25 - this is a better metaphor than the car, huh - especially since lockers can have keys too… - next time I teach it guess CS449

Accessing the value(s) at a pointer CS449

The value-at (or "dereference") operator * is the value-at operator it dereferences a pointer that is, it accesses the memory that a pointer points to it's the inverse of & every time you use it, you remove a star again, this feels backwards? int** ppx = ... int* px = *ppx; int x = *px; goes to the address that ppx contains, and gets the int* there goes to the address that px contains, and gets the int there - you might think of it like a little breadcrumb… it's the "follow the breadcrumb" operator (look up "Hansel and Gretel") - so an int** is two breadcrumbs that lead you to an int… - idk I thought it was cute CS449

Follow the breadcrumbs (animated) 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 x DC00 0100 y DC04 0200 px DC08 py DC0C 0300 these two lines read the same value from the same location in memory! - since they read the same value, both printfs will print 0x300. - really, a regular variable is a bit like an "automatic pointer"… - the compiler knows the address, and whenever you read from or write to a variable, it changes the value in memory at that address - pointers just give us a way to do it manually, on our own terms CS449

Watch out.. (animated) 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 x DC00 0100 px DC04 0300 - the second printf WILL CRASH – it will try to go to address 0x0300, which will, in almost any case, be an invalid address - here's an example of a pointer which is neither null nor valid! CS449

Another way of accessing the value at a pointer arrays are just pointers. char buffer[100]; printf("%p\n", buffer); // oh. when you write array[i], what's happening? well, let's use the address-of operator to help us see... 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. a[i] is 100% interchangeable with *(a + i). we can do math on pointers… this is called pointer arithmetic. - the %p specifier prints the pointer's value in hex. - see 5_arrays_are_pointers.c CS449

Pointer arithmetic array[3] DC0C 3 array[2] DC08 2 array[1] DC04 1 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 how big is each item in the array? (what is sizeof(int)?) when we write array + 2, we don't get 0xDC02, we get 0xDC08 it adds the size of 2 items to the address when you add or subtract offsets to pointers, C "scales" the offsets by multiples of the size of the type they point to. Name Address Value array[3] DC0C 3 array[2] DC08 2 array[1] DC04 1 array[0] DC00 - each item is, in this case, 4 bytes long (sizeof(int) == 4) - keep in mind that array indexes and byte addresses are different things!! - this is why C has to know what a pointer points to – so it can do this math correctly. (in addition to catching bugs. (sorta.)) CS449

Oh yeah, and that stupid -> operator if you have a pointer to a struct, you must access its fields with -> Food* pgrapes = &produce[0]; pgrapes->price = 2.99; (*pgrapes).price = 2.99; these are identical in meaning. - go look at 4_food_struct.c again! CS449

Common pointer patterns CS449

Every problem in CS... ...can be solved with another level of indirection/references/pointers. pointers are the basis of: strings arrays object-oriented programming dynamic memory management pretty much everything your operating system does pretty much everything... everything does. higher level languages often give you more abstract, safer ways of achieving the same things that you can do with pointers CS449

Multi-dimensional arrays we already saw single-dimensional arrays, but… int** arr2d = ... … 1 9 4 3 7 6 a Java int[][] works exactly the same way! 2 5 3 9 6 4 3 7 1 2 3 4 5 6 7 - THIS IS ACTUALLY COMPLETELY DIFFERENT FROM AN "int arr[4][6];" OR SOMETHING - see 5_2d_arrays.c for a comparison CS449

function_that_returns_two_values(&x, &y); Pass-by-reference often you want to give another function access to your variables. fgets(buffer, 100, stdin); int x, y; function_that_returns_two_values(&x, &y); since these functions have access to buffer, x, and y, they can change their values. - again, see 4_struct_food.c for a function that takes a Food by reference! CS449