ch09.htm

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

38:          cout << "Calling FunctionTwo...\n";
39:          FunctionTwo(&Frisky);
40:     return 0;
41:   }
42:
43:   // FunctionOne, passes by value
44:   SimpleCat FunctionOne(SimpleCat theCat)
45:   {
46:                   cout << "Function One. Returning...\n";
47:                   return theCat;
48:   }
49:
50:   // functionTwo, passes by reference
51:   SimpleCat* FunctionTwo (SimpleCat  *theCat)
52:   {
53:                   cout << "Function Two. Returning...\n";
54:                   return theCat;
<TT>55: }</TT></FONT>
<FONT COLOR="#0066FF">
Output: 1:  Making a cat...
2:  Simple Cat Constructor...
3:  Calling FunctionOne...
4:  Simple Cat Copy Constructor...
5:  Function One. Returning...
6:  Simple Cat Copy Constructor...
7:  Simple Cat Destructor...
8:  Simple Cat Destructor...
9:  Calling FunctionTwo...
10: Function Two. Returning...
11: Simple Cat Destructor...
</FONT></PRE>


<BLOCKQUOTE>
	<P>
<HR>
<FONT COLOR="#000077"><B>NOTE:</B></FONT><B> </B>Line numbers will not print. They
	were added to aid in the analysis. 
<HR>


</BLOCKQUOTE>

<P><FONT COLOR="#000077"><TT><B>Anaylsis:</B></TT></FONT><TT><B> </B></TT>A very
simplified <TT>SimpleCat</TT> class is declared on lines 6-12. The constructor, copy
constructor, and destructor all print an informative message so that you can tell
when they've been called.<BR>
On line 34, <TT>main()</TT> prints out a message, and that is seen on output line
1. On line 35, a <TT>SimpleCat</TT> object is instantiated. This causes the constructor
to be called, and the output from the constructor is seen on output line 2.</P>
<P>On line 36, <TT>main()</TT> reports that it is calling <TT>FunctionOne</TT>, which
creates output line 3. Because <TT>FunctionOne()</TT> is called passing the <TT>SimpleCat</TT>
object by value, a copy of the <TT>SimpleCat</TT> object is made on the stack as
an object local to the called function. This causes the copy constructor to be called,
which creates output line 4.</P>
<P>Program execution jumps to line 46 in the called function, which prints an informative
message, output line 5. The function then returns, and returns the <TT>SimpleCat</TT>
object by value. This creates yet another copy of the object, calling the copy constructor
and producing line 6.</P>
<P>The return value from <TT>FunctionOne()</TT> is not assigned to any object, and
so the temporary created for the return is thrown away, calling the destructor, which
produces output line 7. Since <TT>FunctionOne()</TT> has ended, its local copy goes
out of scope and is destroyed, calling the destructor and producing line 8.</P>
<P>Program execution returns to <TT>main()</TT>, and <TT>FunctionTwo()</TT> is called,
but the parameter is passed by reference. No copy is produced, so there's no output.
<TT>FunctionTwo()</TT> prints the message that appears as output line 10 and then
returns the <TT>SimpleCat</TT> object, again by reference, and so again produces
no calls to the constructor or destructor.</P>
<P>Finally, the program ends and <TT>Frisky</TT> goes out of scope, causing one final
call to the destructor and printing output line 11.</P>
<P>The net effect of this is that the call to <TT>FunctionOne()</TT>, because it
passed the cat by value, produced two calls to the copy constructor and two to the
destructor, while the call to <TT>FunctionTwo()</TT> produced none.
<H4 ALIGN="CENTER"><A NAME="Heading34"></A><FONT COLOR="#000077">Passing a const
Pointer</FONT></H4>
<P>Although passing a pointer to <TT>FunctionTwo()</TT> is more efficient, it is
dangerous. <TT>FunctionTwo()</TT> is not allowed to change the <TT>SimpleCat</TT>
object it is passed, yet it is given the address of the <TT>SimpleCat</TT>. This
seriously exposes the object to change and defeats the protection offered in passing
by value.</P>
<P>Passing by value is like giving a museum a photograph of your masterpiece instead
of the real thing. If vandals mark it up, there is no harm done to the original.
Passing by reference is like sending your home address to the museum and inviting
guests to come over and look at the real thing.</P>
<P>The solution is to pass a <TT>const</TT> pointer to <TT>SimpleCat</TT>. Doing
so prevents calling any non-<TT>const</TT> method on <TT>SimpleCat</TT>, and thus
protects the object from change. Listing 9.11 demonstrates this idea.</P>

<P><A NAME="Heading35"></A><FONT SIZE="4" COLOR="#000077"><B>Listing 9.11. Passing
const pointers.</B></FONT>
<PRE><FONT COLOR="#0066FF">
1:  //Listing 9.11
2:       // Passing pointers to objects
3:
4:         #include &lt;iostream.h&gt;
5:
6:         class SimpleCat
7:         {
8:         public:
9:                 SimpleCat();
10:                 SimpleCat(SimpleCat&amp;);
11:                 ~SimpleCat();
12:
13:                 int GetAge() const { return itsAge; }
14:                 void SetAge(int age) { itsAge = age; }
15:
16:         private:
17:                 int itsAge;
18:            };
19:
20:            SimpleCat::SimpleCat()
21:            {
22:                   cout &lt;&lt; &quot;Simple Cat Constructor...\n&quot;;
23:                   itsAge = 1;
24:            }
25:
26:            SimpleCat::SimpleCat(SimpleCat&amp;)
27:            {
28:                   cout &lt;&lt; &quot;Simple Cat Copy Constructor...\n&quot;;
29:            }
30:
31:            SimpleCat::~SimpleCat()
32:            {
33:                   cout &lt;&lt; &quot;Simple Cat Destructor...\n&quot;;
34:            }
35:
36:const SimpleCat * const FunctionTwo (const SimpleCat * const theCat);
37:
38:            int main()
39:            {
40:                   cout &lt;&lt; &quot;Making a cat...\n&quot;;
41:                   SimpleCat Frisky;
42:                   cout &lt;&lt; &quot;Frisky is &quot; ;
43                    cout &lt;&lt; Frisky.GetAge();
44:                   cout &lt;&lt; &quot; years _old\n&quot;;
45:                   int age = 5;
46:                   Frisky.SetAge(age);
47:                   cout &lt;&lt; &quot;Frisky is &quot; ;
48                    cout &lt;&lt; Frisky.GetAge();
49:                   cout &lt;&lt; &quot; years _old\n&quot;;
50:                   cout &lt;&lt; &quot;Calling FunctionTwo...\n&quot;;
51:                   FunctionTwo(&amp;Frisky);
52:                   cout &lt;&lt; &quot;Frisky is &quot; ;
53                    cout &lt;&lt; Frisky.GetAge();
54:                   cout &lt;&lt; &quot; years _old\n&quot;;
55:     return 0;
56:            }
57:
58:    // functionTwo, passes a const pointer
59:    const SimpleCat * const FunctionTwo (const SimpleCat * const theCat)
60:    {
61:             cout &lt;&lt; &quot;Function Two. Returning...\n&quot;;
62:             cout &lt;&lt; &quot;Frisky is now &quot; &lt;&lt; theCat-&gt;GetAge();
63:             cout &lt;&lt; &quot; years old \n&quot;;
64:             // theCat-&gt;SetAge(8);   const!
65:             return theCat;
<TT>66: }</TT></FONT>
<FONT COLOR="#0066FF">
Output: Making a cat...
Simple Cat constructor...
Frisky is 1 years old
Frisky is 5 years old
Calling FunctionTwo...
FunctionTwo. Returning...
Frisky is now 5 years old
Frisky is 5 years old
Simple Cat Destructor...
</FONT></PRE>
<P><FONT COLOR="#000077"><TT><B>Anaylsis:</B></TT></FONT><TT><B> </B>SimpleCat</TT>
has added two accessor functions, <TT>GetAge()</TT> on line 13, which is a <TT>const</TT>
function, and <TT>SetAge()</TT> on line 14, which is not a <TT>const</TT> function.
It has also added the member variable <TT>itsAge</TT> on line 17.<BR>
The constructor, copy constructor, and destructor are still defined to print their
messages. The copy constructor is never called, however, because the object is passed
by reference and so no copies are made. On line 41, an object is created, and its
default age is printed, starting on line 42.</P>
<P>On line 46, <TT>itsAge</TT> is set using the accessor <TT>SetAge</TT>, and the
result is printed on line 47. <TT>FunctionOne</TT> is not used in this program, but
<TT>FunctionTwo()</TT> is called. <TT>FunctionTwo()</TT> has changed slightly; the
parameter and return value are now declared, on line 36, to take a constant pointer
to a constant object and to return a constant pointer to a constant object.</P>
<P>Because the parameter and return value are still passed by reference, no copies
are made and the copy constructor is not called. The pointer in <TT>FunctionTwo()</TT>,
however, is now constant, and thus cannot call the non-<TT>const</TT> method, <TT>SetAge()</TT>.
If the call to <TT>SetAge()</TT> on line 64 was not commented out, the program would
not compile.</P>
<P>Note that the object created in <TT>main()</TT> is not constant, and <TT>Frisky</TT>
can call <TT>SetAge()</TT>. The address of this non-constant object is passed to
<TT>FunctionTwo()</TT>, but because <TT>FunctionTwo()</TT>'s declaration declares
the pointer to be a constant pointer, the object is treated as if it were constant!
<H4 ALIGN="CENTER"><A NAME="Heading37"></A><FONT COLOR="#000077">References as an
Alternative</FONT></H4>
<P>Listing 9.11 solves the problem of making extra copies, and thus saves the calls
to the copy constructor and destructor. It uses constant pointers to constant objects,
and thereby solves the problem of the function changing the object. It is still somewhat
cumbersome, however, because the objects passed to the function are pointers.</P>
<P>Since you know the object will never be null, it would be easier to work with
in the function if a reference were passed in, rather than a pointer. Listing 9.12
illustrates this.</P>

<P><A NAME="Heading38"></A><FONT SIZE="4" COLOR="#000077"><B>Listing 9.12. Passing
references to objects.</B></FONT>
<PRE><FONT COLOR="#0066FF">
1: //Listing 9.12
2: // Passing references to objects
3:
4:   #include &lt;iostream.h&gt;
5:
6:   class SimpleCat
7:   {
8:   public:
9:           SimpleCat();
10:           SimpleCat(SimpleCat&amp;);
11:           ~SimpleCat();
12:
13:           int GetAge() const { return itsAge; }
14:           void SetAge(int age) { itsAge = age; }
15:
16:   private:
17:           int itsAge;
18:      };
19:
20:      SimpleCat::SimpleCat()
21:      {
22:             cout &lt;&lt; &quot;Simple Cat Constructor...\n&quot;;
23:             itsAge = 1;
24:      }
25:
26:      SimpleCat::SimpleCat(SimpleCat&amp;)
27:      {
28:             cout &lt;&lt; &quot;Simple Cat Copy Constructor...\n&quot;;
29:      }
30:
31:      SimpleCat::~SimpleCat()
32:      {
33:             cout &lt;&lt; &quot;Simple Cat Destructor...\n&quot;;
34:      }
35:
36:      const     SimpleCat &amp; FunctionTwo (const SimpleCat &amp; theCat);
37:
38:      int main()
39:      {
40:             cout &lt;&lt; &quot;Making a cat...\n&quot;;
41:             SimpleCat Frisky;
42:             cout &lt;&lt; &quot;Frisky is &quot; &lt;&lt; Frisky.GetAge() &lt;&lt; &quot; years old\n&quot;;
43:             int age = 5;
44:             Frisky.SetAge(age);
45:             cout &lt;&lt; &quot;Frisky is &quot; &lt;&lt; Frisky.GetAge() &lt;&lt; &quot; years old\n&quot;;
46:             cout &lt;&lt; &quot;Calling FunctionTwo...\n&quot;;
47:             FunctionTwo(Frisky);
48:             cout &lt;&lt; &quot;Frisky is &quot; &lt;&lt; Frisky.GetAge() &lt;&lt; &quot; years old\n&quot;;
49:     return 0;
50:      }
51:
52:      // functionTwo, passes a ref to a const object
53:      const SimpleCat &amp; FunctionTwo (const SimpleCat &amp; theCat)
54:      {
55:                      cout &lt;&lt; &quot;Function Two. Returning...\n&quot;;
56:                      cout &lt;&lt; &quot;Frisky is now &quot; &lt;&lt; theCat.GetAge();
57:                      cout &lt;&lt; &quot; years old \n&quot;;
58:                      // theCat.SetAge(8);   const!
59:                      return theCat;
<TT>60: }</TT></FONT>
<FONT COLOR="#0066FF">
Output: Making a cat...
Simple Cat constructor...
Frisky is 1 years old
Frisky is 5 years old
Calling FunctionTwo...
FunctionTwo. Returning...
Frisky is now 5 years old
Frisky is 5 years old
Simple Cat Destructor...</FONT></PRE>
<P><FONT COLOR="#000077"><TT><B>Analysis:</B></TT></FONT><TT><B> </B></TT>The output
is identical to that produced by Listing 9.11. The only significant change is that
<TT>FunctionTwo()</TT> now takes and returns a reference to a constant object. Once
again, working with references is somewhat simpler than working with pointers, and
the same savings and efficiency are achieved, as well as the safety provided by using
<TT>const</TT>.
<H3 ALIGN="CENTER"><A NAME="Heading40"></A><FONT COLOR="#000077">const References</FONT></H3>
<P>C++ programmers do not usually differentiate between &quot;constant reference
to a <TT>SimpleCat</TT> object&quot; and &quot;reference to a constant <TT>SimpleCat</TT>
object.&quot; References themselves can never be reassigned to refer to another object,
and so are always constant. If the keyword <TT>const</TT> is applied to a reference,
it is to make the object referred to constant.
<H3 ALIGN="CENTER"><A NAME="Heading41"></A><FONT COLOR="#000077">When to Use References
and When to Use Pointers</FONT></H3>
<P>C++ programmers strongly prefer references to pointers. References are cleaner