What Is a Pointer?
A pointer is a variable whose value is used to point to another variable.
From this definition, you know two things: first, that a pointer is a variable, so you can assign different values to a pointer variable, and second, that the value contained by a pointer must be an address that indicates the location of another variable in the memory. That's why a pointer is also called an address variable.
Address (Left Value) Versus Content (Right Value)
As you might know, the memory inside your computer is used to hold the binary code of your program, which consists of statements and data, as well as the binary code of the operating system on your machine.
Each memory location must have a unique address so that the computer can read from or write to the memory location without any confusion. This is similar to the concept that each house in a city must have a unique address.
When a variable is declared, a piece of unused memory will be reserved for the variable, and the unique address to the memory will be associated with the name of the variable. The address associated with the variable name is usually called the left value of the variable.
Then, when the variable is assigned a value, the value is stored into the reserved memory location as the content. The content is also called the right value of the variable.
For instance, after the integer variable x is declared and assigned to a value like this:
int x;
x = 7;
the variable x now has two values:
Left value: 1000
Right value: 7
Here the left value, 1000, is the address of the memory location reserved for x. The right value, 7, is the content stored in the memory location. Note that depending on computers and operating systems, the right value of x can be different from one machine to another.
You can imagine that the variable x is the mailbox in front of your house, which has the address (normally the street number) 1000. The right value, 7, can be thought as a letter delivered to the mailbox.
Note that when your C program is being compiled and a value is being assigned to a variable, the C compiler has to check the left value of the variable. If the compiler cannot find the left value, it will issue an error message saying that the variable is undefined in your program. That's why, in C, you have to declare a variable before you can use it. (Imagine a postal worker complaining that he or she cannot drop the letters addressed to you because you haven't built a mailbox yet.)
By using a variable's left value, the C compiler can easily locate the appropriate memory storage reserved for a variable, and then read or write the right value of the variable.
The Address-of Operator (&)
The C language even provides you with an operator, &, in case you want to know the left value of a variable. This operator is called the address-of operator because it can return the address (that is, the left value) of a variable.
The following code, for example,
long int x, y;
y = &x;
assigns the address of the long integer variable x to another variable, y.
Listing 11.1 gives another example of obtaining addresses (that is, left values) of variables.
TYPE
Listing 11.1. Obtaining the left values of variables.
1: /* 11L01.c: Obtaining addresses */
2: #include <stdio.h>
3:
4: main()
5: {
6: char c;
7: int x;
8: float y;
9:
10: printf("c: address=0x%p, content=%c\n", &c, c);
11: printf("x: address=0x%p, content=%d\n", &x, x);
12: printf("y: address=0x%p, content=%5.2f\n", &y, y);
13: c = `A';
14: x = 7;
15: y = 123.45;
16: printf("c: address=0x%p, content=%c\n", &c, c);
17: printf("x: address=0x%p, content=%d\n", &x, x);
18: printf("y: address=0x%p, content=%5.2f\n", &y, y);
19: return 0;
20: }
After the executable (11L01.exe) of this program is created and run from a DOS prompt, the following output is displayed on the screen (note that you might get a different result, depending on your computer and operating system):
OUTPUT
C:\app> 11L01
c: address=0x1AF4, content=@
x: address=0x1AF2, content=-32557
y: address=0x1AF6, content=0.00
c: address=0x1AF4, content=A
x: address=0x1AF2, content=7
y: address=0x1AF6, content=123.45
C:\app>
As you can see in Listing 11.1, there are three variables, c, x, and y, declared in lines 6_8, respectively.
ANALYSIS
The statement in line 10 displays the address (that is, the left value) and the content (that is, the right value) of the character variable c on the screen. Here the &c expression returns the address of c.
Note that the format specifier %p is used in the printf() function of line 10 for displaying the address returned from &c.
Likewise, lines 11 and 12 print out the addresses of x and y, as well as the contents of x and y.
From the first part of the output, you see that the addresses (in hex format) of c, x, and y are 0x1AF4, 0x1AF2, and 0x1AF6. Because these three variables have not been initialized yet, the contents contained in their memory locations are what is left there from the last memory writing.
However, after the initializations that are carried on in lines 13_15, the memory slots reserved for the three variables have the contents of the initial values. Lines 16_18 display the addresses and contents of c, x, and y after the initialization.
You can see in the second part of the output, the contents of c, x, and y are now `A', 7, and 123.45, respectively, with the same memory addresses.
NOTE
The format specifier %p used in the printf() function is supported by the ANSI standard. If, somehow, your compiler does not support %p, you can try to use %u or %lu in the printf() function to convert and print out a left value (that is, an address).
Also, the addresses printed out by the examples in this lesson are obtained by running the examples on my machine. The values may be different from what you can get by running the examples on your machine. This is because the address of a variable may vary from one type of computer to another.
- 20 views
