| << Chapter < Page | Chapter >> Page > |
Since pointers are variables, they can be used without dereferencing. Pointer assignment between two pointers makes them point to the same pointee. So the assignment
iq = ip; copies the contents of ip into iq, thus making iq point to whatever ip pointed to. It makes iq point to the same pointee as ip. Pointer assignment does not touch the pointees. It just changes one pointer to have the same reference as another pointer. After pointer assignment, the two pointers are said to be "sharing" the pointee.
Example Consider the following programs:
main()
{int i = 3, j = 6;
int *p1, *p2;p1 =&i;
p2 =&j;
*p1 = *p2;}
andmain()
{int i = 3, j = 6;
int *p1, *p2;p1 =&i;
p2 =&j;
p1 = p2;}
Suppose the values of variables before executing the last assignment are
| Variable | Address | Value |
|---|---|---|
| i | FFEC | 3 |
| j | FFEE | 6 |
| p1 | FFDA | FFEC |
| p2 | FFDC | FFEE |
After the assignment *p1 = *p2; for the first program:
| Variable | Address | Value |
|---|---|---|
| i | FFEC | 6 |
| j | FFEE | 6 |
| p1 | FFDA | FFEC |
| p2 | FFDC | FFEE |
While the assignment p1 = p2 for the second program results
| Variable | Address | Value |
|---|---|---|
| i | FFEC | 3 |
| j | FFEE | 6 |
| p1 | FFDA | FFEE |
| p2 | FFDC | FFEE |
Pointer variables with automatic storage duration start with an undefined value, unless their declaration contains an explicit initializer. You can initialize a pointer with the following kinds of initializers:
Besides using assignments to make a pointer refer to a given object or function, you can also modify an object pointer using arithmetic operations. When you perform pointer arithmetic , the compiler automatically adapts the operation to the size of the objects referred to by the pointer type.
You can perform the following operations on pointers to objects:
If ip points to the integer x, then *ip can occur in any context where x could, so
*ip = *ip + 10;
The unary operators * and&bind more tightly than arithmetic operators, so the assignment
y = *ip + 1
takes whatever ip points at, adds 1, and assigns the result to y, while
*ip += 1
increments what ip points to, as do
++*ip
and
(*ip)++
The parentheses are necessary in this last example; without them, the expression would increment ip instead of what it points to, because unary operators like * and ++ associate right to left.
When you subtract one pointer from another, the two pointers must have the same basic type, although you can disregard any type. Furthermore, you may compare any pointer with a null pointer constant using the equality operators (== and !=), and you may compare any object pointer with a pointer to void.
A pointer variable is itself an object in memory, which means that a pointer can point to it. To declare a pointer to a pointer , you must use two asterisks, as in the following Example
Notification Switch
Would you like to follow the 'Introduction to computer science' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|