ch08.htm

一本好的VC学习书,本人就是使用这本书开始学习的vc,希望能对大家有帮助

yourAge = *pAge;
</FONT></PRE>
<P>The indirection operator (<TT>*</TT>) in front of the variable <TT>pAge</TT> means
&quot;the value stored at.&quot; This assignment says, &quot;Take the value stored
at the address in <TT>pAge</TT> and assign it to <TT>yourAge</TT>.&quot;


<BLOCKQUOTE>
	<P>
<HR>
<FONT COLOR="#000077"><B>NOTE:</B></FONT><B> </B>The indirection operator (<TT>*</TT>)
	is used in two distinct ways with pointers: declaration and dereference. When a pointer
	is declared, the star indicates that it is a pointer, not a normal variable. For
	example,</P>
	<PRE><FONT COLOR="#0066FF">
unsigned short * pAge = 0; // make a pointer to an unsigned short</FONT></PRE>

</BLOCKQUOTE>

<PRE><FONT COLOR="#0066FF"></FONT></PRE>


<BLOCKQUOTE>
	<P>When the pointer is dereferenced, the indirection operator indicates that the
	value at the memory location stored in the pointer is to be accessed, rather than
	the address itself.</P>
	<PRE><FONT COLOR="#0066FF">*pAge = 5; // assign 5 to the value at pAge</FONT></PRE>

</BLOCKQUOTE>

<PRE><FONT COLOR="#0066FF"></FONT></PRE>


<BLOCKQUOTE>
	<P>Also note that this same character (<TT>*</TT>) is used as the multiplication
	operator. The compiler knows which operator to call, based on context. 
<HR>


</BLOCKQUOTE>

<H4 ALIGN="CENTER"><A NAME="Heading11"></A><FONT COLOR="#000077">Pointers, Addresses,
and Variables</FONT></H4>
<P>It is important to distinguish between a pointer, the address that the pointer
holds, and the value at the address held by the pointer. This is the source of much
of the confusion about pointers.</P>
<P>Consider the following code fragment:</P>
<PRE><FONT COLOR="#0066FF">int theVariable = 5;
int * pPointer = &amp;theVariable ;
</FONT></PRE>
<P><TT>theVariable</TT> is declared to be an integer variable initialized with the
value <TT>5</TT>. <TT>pPointer</TT> is declared to be a pointer to an integer; it
is initialized with the address of <TT>theVariable</TT>.<TT> pPointer</TT> is the
pointer. The address that <TT>pPointer</TT> holds is the address of <TT>theVariable</TT>.
The value at the address that <TT>pPointer</TT> holds is <TT>5</TT>. Figure 8.3 shows
a schematic representation of <TT>theVariable</TT> and <TT>pPointer</TT>.<BR>
<BR>
<A NAME="Heading12"></A><A HREF="figure3.jpg" tppabs="http://www.mcp.com/814147200/0-672/0-672-31070-8/art/ch08/figure3.jpg"><FONT COLOR="#000077">Figure
8.3.</FONT></A><FONT COLOR="#000077"> </FONT><I>A schematic representation of memory.</I>
<H4 ALIGN="CENTER"><A NAME="Heading13"></A><FONT COLOR="#000077">Manipulating Data
by Using Pointers</FONT></H4>
<P>Once a pointer is assigned the address of a variable, you can use that pointer
to access the data in that variable. Listing 8.2 demonstrates how the address of
a local variable is assigned to a pointer and how the pointer manipulates the values
in that variable.</P>
<P><A NAME="Heading14"></A><FONT SIZE="4" COLOR="#000077"><B>Listing 8.2. Manipulating
data by using pointers.</B></FONT></P>
<PRE><FONT COLOR="#0066FF">1:     // Listing 8.2 Using pointers
2:
3:     #include &lt;iostream.h&gt;
4:
5:     typedef unsigned short int USHORT;
6:     int main()
7:     {
8:        USHORT myAge;         // a variable
9:        USHORT * pAge = 0;    // a pointer
10:       myAge = 5;
11:       cout &lt;&lt; &quot;myAge: &quot; &lt;&lt; myAge &lt;&lt; &quot;\n&quot;;
12:
13:       pAge = &amp;myAge;     // assign address of myAge to pAge
14:
15:       cout &lt;&lt; &quot;*pAge: &quot; &lt;&lt; *pAge &lt;&lt; &quot;\n\n&quot;;
16:
17:       cout &lt;&lt; &quot;*pAge = 7\n&quot;;
18:
19:       *pAge = 7;         // sets myAge to 7
20:
21:       cout &lt;&lt; &quot;*pAge: &quot; &lt;&lt; *pAge &lt;&lt; &quot;\n&quot;;
22:       cout &lt;&lt; &quot;myAge: &quot; &lt;&lt; myAge &lt;&lt; &quot;\n\n&quot;;
23:
24:
25:       cout &lt;&lt; &quot;myAge = 9\n&quot;;
26:
27:       myAge = 9;
28:
29:       cout &lt;&lt; &quot;myAge: &quot; &lt;&lt; myAge &lt;&lt; &quot;\n&quot;;
30:       cout &lt;&lt; &quot;*pAge: &quot; &lt;&lt; *pAge &lt;&lt; &quot;\n&quot;;
31:
32:    return 0;
<TT>33: }</TT></FONT>
<FONT COLOR="#0066FF">
Output: myAge: 5
*pAge: 5

*pAge = 7
*pAge: 7
myAge: 7

myAge = 9
myAge: 9
*pAge: 9
</FONT></PRE>
<P><FONT COLOR="#000077"><B>Analysis:</B></FONT><B> </B>This program declares two
variables: an <TT>unsigned short</TT>, <TT>myAge</TT>, and a pointer to an <TT>unsigned
short, pAge</TT>. <TT>myAge</TT> is assigned the value <TT>5</TT> on line 10; this
is verified by the printout in line 11.<BR>
On line 13, <TT>pAge</TT> is assigned the address of <TT>myAge</TT>. On line 15,
<TT>pAge</TT> is dereferenced and printed, showing that the value at the address
that <TT>pAge</TT> stores is the <TT>5</TT> stored in <TT>myAge</TT>. In line 17,
the value <TT>7</TT> is assigned to the variable at the address stored in <TT>pAge</TT>.
This sets <TT>myAge</TT> to <TT>7</TT>, and the printouts in lines 21-22 confirm
this.</P>
<P>In line 27, the value <TT>9</TT> is assigned to the variable <TT>myAge</TT>. This
value is obtained directly in line 29 and indirectly (by dereferencing <TT>pAge</TT>)
in line 30.
<H4 ALIGN="CENTER"><A NAME="Heading16"></A><FONT COLOR="#000077">Examining the Address</FONT></H4>
<P>Pointers enable you to manipulate addresses without ever knowing their real value.
After today, you'll take it on faith that when you assign the address of a variable
to a pointer, it really has the address of that variable as its value. But just this
once, why not check to make sure? Listing 8.3 illustrates this idea.</P>
<P><A NAME="Heading17"></A><FONT SIZE="4" COLOR="#000077"><B>Listing 8.3. Finding
out what is stored in pointers.</B></FONT></P>
<PRE><FONT COLOR="#0066FF">
1:      // Listing 8.3 What is stored in a pointer.
2:
3:     #include &lt;iostream.h&gt;
4:
5:     typedef unsigned short int USHORT;
6:     int main()
7:     {
8:        unsigned short int myAge = 5, yourAge = 10;
9:        unsigned short int * pAge = &amp;myAge;  // a pointer
10:
11:       cout &lt;&lt; &quot;myAge:\t&quot; &lt;&lt; myAge &lt;&lt;  &quot;\tyourAge:\t&quot; &lt;&lt; yourAge &lt;&lt; &quot;\n&quot;;
12:       cout &lt;&lt; &quot;&amp;myAge:\t&quot; &lt;&lt; &amp;myAge &lt;&lt;  &quot;\t&amp;yourAge:\t&quot; &lt;&lt; &amp;yourAge &lt;&lt;&quot;\n&quot;;
13:
14:       cout &lt;&lt; &quot;pAge:\t&quot; &lt;&lt; pAge &lt;&lt; &quot;\n&quot;;
15:       cout &lt;&lt; &quot;*pAge:\t&quot; &lt;&lt; *pAge &lt;&lt; &quot;\n&quot;;
16:
17:       pAge = &amp;yourAge;       // reassign the pointer
18:
19:       cout &lt;&lt; &quot;myAge:\t&quot; &lt;&lt; myAge &lt;&lt;  &quot;\tyourAge:\t&quot; &lt;&lt; yourAge &lt;&lt; &quot;\n&quot;;
20:       cout &lt;&lt; &quot;&amp;myAge:\t&quot; &lt;&lt; &amp;myAge &lt;&lt;  &quot;\t&amp;yourAge:\t&quot; &lt;&lt; &amp;yourAge &lt;&lt;&quot;\n&quot;;
21:
22:       cout &lt;&lt; &quot;pAge:\t&quot; &lt;&lt; pAge &lt;&lt; &quot;\n&quot;;
23:       cout &lt;&lt; &quot;*pAge:\t&quot; &lt;&lt; *pAge &lt;&lt; &quot;\n&quot;;
24:
25:       cout &lt;&lt; &quot;&amp;pAge:\t&quot; &lt;&lt; &amp;pAge &lt;&lt; &quot;\n&quot;;
26:    return 0;
<TT>27: }</TT>
Output: myAge:     5             yourAge:  10
&amp;myAge:    0x355C        &amp;yourAge: 0x355E
pAge:      0x355C
*pAge:     5
myAge:     5             yourAge:  10
&amp;myAge:    0x355C        &amp;yourAge: 0x355E
pAge:      0x355E
*pAge:     10
&amp;pAge:     0x355A
</FONT></PRE>
<P>(Your output may look different.)</P>
<P><FONT COLOR="#000077"><B>Analysis:</B></FONT><B> </B>In line 8, <TT>myAge</TT>
and <TT>yourAge</TT> are declared to be variables of type <TT>unsigned short</TT>
integer. In line 9, <TT>pAge</TT> is declared to be a pointer to an <TT>unsigned
short</TT> integer, and it is initialized with the address of the variable <TT>myAge</TT>.<BR>
Lines 11 and 12 print the values and the addresses of <TT>myAge</TT> and <TT>yourAge</TT>.
Line 14 prints the contents of <TT>pAge</TT>, which is the address of <TT>myAge</TT>.
Line 15 prints the result of dereferencing <TT>pAge</TT>, which prints the value
at <TT>pAge</TT>--the value in <TT>myAge</TT>, or <TT>5</TT>.</P>
<P>This is the essence of pointers. Line 14 shows that <TT>pAge</TT> stores the address
of <TT>myAge</TT>, and line 15 shows how to get the value stored in <TT>myAge</TT>
by dereferencing the pointer <TT>pAge</TT>. Make sure that you understand this fully
before you go on. Study the code and look at the output.</P>
<P>In line 17, <TT>pAge</TT> is reassigned to point to the address of <TT>yourAge</TT>.
The values and addresses are printed again. The output shows that <TT>pAge</TT> now
has the address of the variable <TT>yourAge</TT> and that dereferencing obtains the
value in <TT>yourAge</TT>.</P>
<P>Line 25 prints the address of <TT>pAge</TT> itself. Like any variable, it has
an address, and that address can be stored in a pointer. (Assigning the address of
a pointer to another pointer will be discussed shortly.)


<BLOCKQUOTE>
	<P>
<HR>
<B>DO</B> use the indirection operator (<TT>*</TT>) to access the data stored at
	the address in a pointer. <B>DO</B> initialize all pointers either to a valid address
	or to <TT>null</TT> (<TT>0</TT>)<B>. DO </B>remember the difference between the address
	in a pointer and the value at that address. 
<HR>


</BLOCKQUOTE>

<H3 ALIGN="CENTER"><A NAME="Heading19"></A><FONT COLOR="#000077">Pointers</FONT></H3>
<P>To declare a pointer, write the type of the variable or object whose address will
be stored in the pointer, followed by the pointer operator (<TT>*</TT>) and the name
of the pointer. For example,</P>
<PRE><FONT COLOR="#0066FF">unsigned short int * pPointer = 0;
</FONT></PRE>
<P>To assign or initialize a pointer, prepend the name of the variable whose address
is being assigned with the <TT>address of</TT> operator (<TT>&amp;</TT>). For example,</P>
<PRE><FONT COLOR="#0066FF">unsigned short int theVariable = 5;

unsigned short int * pPointer = &amp; theVariable;
</FONT></PRE>
<P>To dereference a pointer, prepend the pointer name with the dereference operator
(<TT>*</TT>). For example,</P>
<PRE><FONT COLOR="#0066FF">unsigned short int theValue = *pPointer
</FONT></PRE>
<H3 ALIGN="CENTER"><A NAME="Heading20"></A><FONT COLOR="#000077">Why Would You Use
Pointers?</FONT></H3>
<P>So far you've seen step-by-step details of assigning a variable's address to a
pointer. In practice, though, you would never do this. After all, why bother with
a pointer when you already have a variable with access to that value? The only reason
for this kind of pointer manipulation of an automatic variable is to demonstrate
how pointers work. Now that you are comfortable with the syntax of pointers, you
can put them to good use. Pointers are used, most often, for three tasks:

<UL>
	<LI>Managing data on the free store.
	<P>
	<LI>Accessing class member data and functions.
	<P>
	<LI>Passing variables by reference to functions.
</UL>

<P>This rest of this chapter focuses on managing data on the free store and accessing
class member data and functions. Tomorrow you will learn about passing variables
by reference.
<H3 ALIGN="CENTER"><A NAME="Heading21"></A><FONT COLOR="#000077">The Stack and the
Free Store</FONT></H3>
<P>In the &quot;Extra Credit&quot; section following the discussion of functions
in Day 5, five areas of memory are mentioned:

<UL>
	<LI>Global name space
	<P>
	<LI>The free store
	<P>
	<LI>Registers
	<P>
	<LI>Code space
	<P>
	<LI>The stack
</UL>

<P>Local variables are on the stack, along with function parameters. Code is in code
space, of course, and global variables are in global name space. The registers are
used for internal housekeeping functions, such as keeping track of the top of the
stack and the instruction pointer. Just about all remaining memory is given over
to the free store, which is sometimes referred to as the heap.</P>
<P>The problem with local variables is that they don't persist: When the function
returns, the local variables are thrown away. Global variables solve that problem
at the cost of unrestricted access throughout the program, which leads to the creation
of code that is difficult to understand and maintain. Putting data in the free store
solves both of these problems.</P>
<P>You can think of the free store as a massive section of memory in which thousands
of sequentially numbered cubbyholes lie waiting for your data. You can't label these
cubbyholes, though, as you can with the stack. You must ask for the address of the
cubbyhole that you reserve and then stash that address away in a pointer.</P>
<P>One way to think about this is with an analogy: A friend gives you the 800 number
for Acme Mail Order. You go home and program your telephone with that number, and
then you throw away the piece of paper with the number on it. If you push the button,
a telephone rings somewhere, and Acme Mail Order answers. You don't remember the
number, and you don't know where the other telephone is located, but the button gives
you access to Acme Mail Order. Acme Mail Order is your data on the free store. You
don't know where it is, but you know how to get to it. You access it by using its
address--in this case, the telephone number. You don't have to know that number;
you just have to put it into a pointer (the button). The pointer gives you access
to your data without bothering you with the details.</P>