<< Chapter < Page Chapter >> Page >

Pointer assignment

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

Initializing pointers

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:

  • A null pointer constant.
  • A pointer to the same type, or to a less qualified version of the same type.
  • A void pointer, if the pointer being initialized is not a function pointer. Here again, the pointer being initialized can be a pointer to a more qualified type.

Operators on pointers

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:

  • Adding an integer to, or subtracting an integer from, a pointer.
  • Subtracting one pointer from another.
  • Comparing two pointers.

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.

Pointer to pointer

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

Get Jobilize Job Search Mobile App in your pocket Now!

Get it on Google Play Download on the App Store Now




Source:  OpenStax, Introduction to computer science. OpenStax CNX. Jul 29, 2009 Download for free at http://cnx.org/content/col10776/1.1
Google Play and the Google Play logo are trademarks of Google Inc.

Notification Switch

Would you like to follow the 'Introduction to computer science' conversation and receive update notifications?

Ask