Pointers
A pointer in C holds the memory address of a value
the value of a pointer is an address
the value of the memory location pointed at can be obtained by
address)
memory location address
p
129 10000
pointer 10004 77 10001
31542 10002
dereferencing:
108 10003
*
97 10004
542 10005
100652 10006
1
C pointers
a pointer is the address of a memory location
no explicit type information associated with it
arithmetic on pointers is allowed, e.g.:
*(p+27)
2
Declaring pointer variables
Two new operators (unary, prefix):
&
*
Declarations:
a pointer x to something of type T is declared as
T *x
Example: int *p; // p: pointer to an int
char **w; // w: pointer to a pointer to a char
Using pointer-related operators
If x is a variable, &x is the address of x
If p is a pointer, *p is the value of whatever points to
*(&p) p always
4
Arrays
An array in C is just a contiguous sequence of
memory locations
size of each element depends on type
the length of the array is not part of the array type
the language does not require that array accesses be
checked to be within the array bounds
out-of-
More arrays
Consider an array declared as:
int A[20];
the value of A[i] is the contents of the memory location
occupied by element i of A;
the value of A is the address of the array A, i.e., &(A[0]);
this does not have size information associated with it.
6
More arrays
To pass an array as an argument to a function, you
pass the array name
since the value of the array name is the address of the
array, what is actually passed is a pointer to the array
This does not have size information associated
the called function does not know how big the array is
need to provide a mechanism for callee to figure this out:
either pass the size of the array separately; or
terminate the array with a known value (e.g., 0)
scanf() and pointers
To read input using scanf(), we have to provide:
a format string with conversion specifications (%d, %s, etc.)
that says what kind of value is being read in; and
a pointer to (i.e., the address of) a memory area where the
value is to be placed
Reading in an integer:
int x;
// &x address of x
Reading in a string:
// str address of the array str
8
*p++ vs. (*p)++
x
p
after x = *p++ after x = (*p)++
x x
p p
Two common pointer problems
Uninitialized pointers
the pointer has not been initialized to point to a valid
location
Dangling pointers
the pointer points at a memory location that has actually
been deallocated
10
Background: Runtime Memory Organization
0xffffffff high addresses
operating system
stack
(grows downwards)
memory mapped files
heap
(grows upwards)
global data
code low addresses
0x00000000
11
Background: Runtime Memory Organization
Code: Runtime stack:
stack growth
}
top of
stack
}
}
12
Background: Runtime Memory Organization
Code: Runtime stack:
stack growth
}
top of
stack
}
}
13
Background: Runtime Memory Organization
Code: Runtime stack:
stack growth
}
}
} top of
stack
14
Background: Runtime Memory Organization
Code: Runtime stack:
stack growth
}
}
}
{
top of
stack
}
15
Background: Runtime Memory Organization
Code: Runtime stack:
stack growth
}
}
} top of
stack
stack frame
{ (deallocated)
16
Background: Runtime Memory Organization
Code: Runtime stack:
stack growth
}
top of
stack
} stack frame
stack frame
{
17
Background: Runtime Memory Organization
Code: Runtime stack:
stack growth
}
} stack frame
top of stack frame
{ stack
18
Structs
A struct is
an aggregate data structure, i.e., a collection of other
data;
by contrast, arrays contain components of the same type
fields are accessed by name
by contrast, array elements are accessed by position
Unlike Java classes, a struct can only contain data,
not code.
19
Declaring structs
A node for a linked list struct node
of integers: val
next
struct node {
int val;
struct node *next;
}
used to refer to the
structure
20
Accessing structure fields
Given Given
a struct s containing a a pointer p to a struct s
field f containing a field f
to access f, we write to access f we write
s.f declares x, y to be p->f // eqvt. to: (*p).f
variables of type
Example: struct foo
Example:
struct foo { struct foo {
int count, bar[10];
int count, bar[10];
} *p, *q;
} x, y;
x.count = y.bar[3]; p->count = q->bar[3];
21
Operator Precedence and Associativity
Operator precedence and associativity define how an
expression is parsed and evaluated
The text (King, C Programming: A Modern Approach),
Appendix A has a full list of all C operator precedences
Some highlights: in decreasing order of precedence:
postfix expressions ( [ ] ( ) -> . ++postfix --postfix )
unary expressions ( ++prefix --prefix & * + - ~ ! sizeof )
type cast
arithmetic: multiplicative additive bit-shift
relational (not all of the same precedence)
bitwise operators (not all of the same precedence)
22
Operator Precedence Examples
Decreasing order of How are these parsed?
precedence: *p++ ++ binds tighter than *:
postfix expressions *(p++) not: (*p)++
[ ] ( ) -> . ++post --post
*p->q -> binds tighter than *:
unary expressions *(p->q) not: (*p)->q
++pre --pre & *deref + - ~ ! sizeof
*A[10] [ ] binds tighter than *:
type cast *(A[10]) not: (*A)[10]
arithmetic
*p->q++ -> and ++ left-associative:
*( (p->q) ++ )
23
l-values for structs and pointers
e.name is an l-value iff e is an l-value
e->name is always an l-value, regardless of whether e
is an l-value
*e is always an l-value, regardless of whether e is an
l-value
the operand of an address-of operator & must be an
l-value
the operand of a unary ++ or -- operator (prefix or
postfix) must be an l-value
24
