Lecture 11 - More Pointers, Debugging Information Flashcards
dereferencing
- accessing the value stored at the memory address that the pointer is pointing to
- this is done by using the dereference operator *
- ex. p = &x points to ex, *p = 5 is equivalent to x
definition vs. indirection
- definition refers to declaring a pointer variable that can store the memory access of another variable
- indirection means accessing the value stored at the memory address that the pointer holds (done using the dereference operator *)
- definiton int *p = &x; vs. indirection *p =5
more pointer basics
- pointers can be used just as arrays
- arrays are equivalent to pointers
- “address-of” (&) can be used on array elements
- “address-of” can be used for structs
pointers can be used as arrays
- when we obtain the address of a variable (ptr = &x;)
- you can dereference it two ways
- y = *ptr (treat as pointer) or z = ptr[0] (or 1 element array)
- the effect and meaning are exactly the same
arrays are eqiuvalent to pointers
- when you assign an array to something, you’re assigning a pointer (ptr = array)
- when you pass an army to something, you’re passing a pointer
- when you return an array, you return a pointer
differences between arrays and pointers
- you can assign something new to a pointer, but an array ALWAYS points to the same things
- an array def. allocates spaces for all the elements but NOT the pointer
- a pointer definition allocates space only for the pointer value
- a function parameter defined as an array is really a pointer
address-of can reused on array elements
- since an array is already an address, it makes no sense to find the address of an array (ptr = &array is WRONG)
- but you can find address of an element (prt = &array[3] is GOOD)
alternative way to get the address of an element
- ptr = array (the address of array[0])
- ptr = ptr + 3 goes to the third element
- can do ptr++, ptr–
pointer arithmetic
- you can add, subtract, decrement, increment
- (ex. ++ptr, ptr++)
- you can subtract one pointer from another
how to find the problem when pointers of wrong
- C does not protect from a potential disaster
- you can carefully examine every statement in your program until you understand what happened
- you can use a debugger
- print statements
basic debugger (*nix)
-gdb is the root of all UNIX debuggers
- very useful in determining where the segmentation fault occurred (not necessarily what caused it)
address-of structures
- you can get the address of anything that stores a value.. including a structure
- ex. struct coord *p = 0;
- (p).x = 1; (p).y = (*p).x
precedence and pointers
- its a little verbose to say (*p).x
- if the parentheses are omitted, the natural precedence is *(p.x) means something really different
operator used to refer to a field x within structure pointed to by p
- p -> x
structures containing pointers
- structs can contain any definition except a functino
- a pointer def. can be placed in a structure declaration
- we can define a pointer to the type of struct that we’re presently declaring
example of internal pointer
struct node {
int val;
struct node *next;
};
struct node g_node = {12, NULL};
why put a pointer in a structure?
- no real use in creating a struct that points to itself
- if we have pointers pointing to other structs they can be organized into a list (linked list)
- ex. struct nodes a, b, and c
a.next = &b, b.next = &c, c.next = &a;
5 steps to use a debugger
- gcc -g file.c -o file
- gdb file
- (gdb) run
- (gdb) bt
- (gdb) quit
(*p).x vs. *(p.x)
- (*p).x accesses the x member of the structure that p is pointing to
- *(p.x) only makes sense if x in struct is a pointer itself
.next and node
- node is a pointer to a node, then p -> next gives access to the next node
- p -> next helps access the second node p -> next -> data accesses its data
