ch19.htm

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

107:         cout << "theZoo[" << j << "]:\t";
108:         theZoo[j].Display();
109:         cout << endl;
110:      }
111:
112:      for (int k = 0; k < theArray.GetSize(); k++)
113:         delete &theZoo[j];
114:     return 0;
<TT>115: }</TT>
Output: theArray[0]:    0            theZoo[0]:    0
theArray[1]:    2            theZoo[1]:    3
theArray[2]:    4            theZoo[2]:    6
theArray[3]:    6            theZoo[3]:    9
theArray[4]:    8            theZoo[4]:    12
theArray[5]:    10           theZoo[5]:    15
theArray[6]:    12           theZoo[6]:    18
theArray[7]:    14           theZoo[7]:    21
theArray[8]:    16           theZoo[8]:    24
theArray[9]:    18           theZoo[9]:    27
</FONT></PRE>
<P><FONT COLOR="#000077"><B>Analysis:</B></FONT><B> </B>Lines 8 to 26 provide a stripped-down
<TT>Animal</TT> class, created here so that there are objects of a user-defined type
to add to the array.<BR>
<BR>
Line 29 declares that what follows is a template, and that the parameter to the template
is a type, designated as <TT>T</TT>. The <TT>Array</TT> class has two constructors
as shown, the first of which takes a size and defaults to the constant integer <TT>DefaultSize</TT>.</P>
<P>The assignment and offset operators are declared, with the latter declaring both
a <TT>const</TT> and a non-<TT>const</TT> variant. The only accessor provided is
<TT>GetSize()</TT>, which returns the size of the array.</P>
<P>One can certainly imagine a fuller interface, and, for any serious <TT>Array</TT>
program, what has been supplied here would be inadequate. At a minimum, operators
to remove elements, to expand the array, to pack the array, and so forth would be
required.</P>
<P>The private data consists of the size of the array and a pointer to the actual
in-memory array of objects.
<H3 ALIGN="CENTER"><A NAME="Heading12"></A><FONT COLOR="#000077">Template Functions</FONT></H3>
<P>If you want to pass an array object to a function, you must pass a particular
instance of the array, not a template. Therefore, if <TT>SomeFunction()</TT> takes
an integer array as a parameter, you may write</P>
<PRE><FONT COLOR="#0066FF">void SomeFunction(Array&lt;int&gt;&amp;);    // ok
</FONT></PRE>
<P>but you may not write</P>
<PRE><FONT COLOR="#0066FF">void SomeFunction(Array&lt;T&gt;&amp;);   // error!
</FONT></PRE>
<P>because there is no way to know what a <TT>T&amp;</TT> is. You also may not write</P>
<PRE><FONT COLOR="#0066FF">void SomeFunction(Array &amp;);     // error!
</FONT></PRE>
<P>because there is no class <TT>Array</TT>--only the template and the instances.</P>
<P>To accomplish the more general approach, you must declare a template function.</P>
<PRE><FONT COLOR="#0066FF">template &lt;class T&gt;
void MyTemplateFunction(Array&lt;T&gt;&amp;);    // ok
</FONT></PRE>
<P>Here the function <TT>MyTemplateFunction()</TT> is declared to be a template function
by the declaration on the top line. Note that template functions can have any name,
just as other functions can.</P>
<P>Template functions can also take instances of the template, in addition to the
parameterized form. The following is an example:</P>
<PRE><FONT COLOR="#0066FF">template &lt;class T&gt;
void MyOtherFunction(Array&lt;T&gt;&amp;, Array&lt;int&gt;&amp;);   // ok
</FONT></PRE>
<P>Note that this function takes two arrays: a parameterized array and an array of
integers. The former can be an array of any object, but the latter is always an array
of integers.
<H3 ALIGN="CENTER"><A NAME="Heading13"></A><FONT COLOR="#000077">Templates and Friends</FONT></H3>
<P>Template classes can declare three types of friends:

<UL>
	<LI>A non-template friend class or function.
	<P>
	<LI>A general template friend class or function.
	<P>
	<LI>A type-specific template friend class or function.
</UL>

<H4 ALIGN="CENTER"><A NAME="Heading14"></A><FONT COLOR="#000077">Non-Template Friend
Classes and Functions</FONT></H4>
<P>It is possible to declare any class or function to be a friend to your template
class. Each instance of the class will treat the friend properly, as if the declaration
of friendship had been made in that particular instance. Listing 19.3 adds a trivial
friend function, <TT>Intrude()</TT>, to the template definition of the <TT>Array</TT>
class, and the driver program invokes <TT>Intrude()</TT>. Because it is a friend,
<TT>Intrude()</TT> can then access the private data of the <TT>Array</TT>. Because
this is not a template function, it can only be called on <TT>Array</TT>s of <TT>int</TT>.


<BLOCKQUOTE>
	<P>
<HR>
<FONT COLOR="#000077"><B>NOTE:</B></FONT><B> </B>To use Listing 19.3, copy lines
	1-26 of Listing 19.2 after line 1 of this listing, and then copy lines 51-86 of Listing
	19.2 after line 37 of this listing. 
<HR>


</BLOCKQUOTE>

<P><A NAME="Heading15"></A><FONT SIZE="4" COLOR="#000077"><B>Listing 19.3. Non-template
friend function.</B></FONT>
<PRE><FONT COLOR="#0066FF">1:     // Listing 19.3 - Type specific friend functions in templates
2:
3:      template &lt;class T&gt;  // declare the template and the parameter
4:      class Array            // the class being parameterized
5:      {
6:      public:
7:         // constructors
8:         Array(int itsSize = DefaultSize);
9:         Array(const Array &amp;rhs);
10:        ~Array() { delete [] pType; }
11:
12:        // operators
13:        Array&amp; operator=(const Array&amp;);
14:        T&amp; operator[](int offSet) { return pType[offSet]; }
15:        const T&amp; operator[](int offSet) const 
16:            { return pType[offSet]; }
17:        // accessors
18:        int GetSize() const { return itsSize; }
19:
20:       // friend function
21:       friend void Intrude(Array&lt;int&gt;);
22:
23:     private:
24:        T *pType;
25:        int  itsSize;
26:     };
27:
28:       // friend function. Not a template, can only be used
29:       // with int arrays! Intrudes into private data.
30:      void Intrude(Array&lt;int&gt; theArray)
31:      {
32:       cout &lt;&lt; &quot;\n*** Intrude ***\n&quot;;
33:       for (int i = 0; i &lt; theArray.itsSize; i++)
34:          cout &lt;&lt; &quot;i: &quot; &lt;&lt;    theArray.pType[i] &lt;&lt; endl;
35:       cout &lt;&lt; &quot;\n&quot;;
36:      }
37:
38:     // driver program
39:     int main()
40:     {
41:        Array&lt;int&gt; theArray;      // an array of integers
42:        Array&lt;Animal&gt; theZoo;     // an array of Animals
43:        Animal *pAnimal;
44:
45:        // fill the arrays
46:        for (int i = 0; i &lt; theArray.GetSize(); i++)
47:        {
48:           theArray[i] = i*2;
49:           pAnimal = new Animal(i*3);
50:           theZoo[i] = *pAnimal;
51:        }
52:
53:        int j, k;
54:        for (j = 0; j &lt; theArray.GetSize(); j++)
55:        {
56:           cout &lt;&lt; &quot;theZoo[&quot; &lt;&lt; j &lt;&lt; &quot;]:\t&quot;;
57:           theZoo[j].Display();
58:           cout &lt;&lt; endl;
59:        }
60:        cout &lt;&lt; &quot;Now use the friend function to &quot;;
61:        cout &lt;&lt; &quot;find the members of Array&lt;int&gt;&quot;;
62:        Intrude(theArray);
63:
63:        // return the allocated memory before the arrays are destroyed.
64:        for (k = 0; k &lt; theArray.GetSize(); k++)
65:           delete &amp;theZoo[j];
66:
67:        cout &lt;&lt; &quot;\n\nDone.\n&quot;;
68:        return 0;
<TT>69: }</TT></FONT>
<FONT COLOR="#0066FF">
Output: theZoo[0]:      0
theZoo[1]:      3
theZoo[2]:      6
theZoo[3]:      9
theZoo[4]:      12
theZoo[5]:      15
theZoo[6]:      18
theZoo[7]:      21
theZoo[8]:      24
theZoo[9]:      27
Now use the friend function to find the members of Array&lt;int&gt;
*** Intrude ***
i: 0
i: 2
i: 4
i: 6
i: 8
i: 10
i: 12
i: 14
i: 16
i: 18

Done.
</FONT></PRE>
<P><FONT COLOR="#000077"><B>Analysis: </B></FONT>The declaration of the <TT>Array</TT>
template has been extended to include the friend function <TT>Intrude()</TT>. This
declares that every instance of an array will consider <TT>Intrude()</TT> to be a
friend function; thus, <TT>Intrude()</TT> will have access to the private member
data and functions of the array instance.<BR>
<BR>
On line 33, <TT>Intrude()</TT> accesses <TT>itsSize</TT> directly, and on line 34
it accesses <TT>pType</TT> directly. This trivial use of these members was unnecessary
because the <TT>Array</TT> class provides public accessors for this data, but it
serves to demonstrate how friend functions can be declared with templates.
<H4 ALIGN="CENTER"><A NAME="Heading17"></A><FONT COLOR="#000077">General Template
Friend Class or Function</FONT></H4>
<P>It would be helpful to add a display operator to the <TT>Array</TT> class. One
approach would be to declare a display operator for each possible type of <TT>Array</TT>,
but this would undermine the whole point of having made <TT>Array</TT> a template.</P>
<P>What is needed is an insertion operator that works for any possible type of <TT>Array</TT>.</P>
<PRE><FONT COLOR="#0066FF">ostream&amp; operator&lt;&lt; (ostream&amp; Array&lt;T&gt;&amp;);
</FONT></PRE>
<P>To make this work, we need to declare <TT>operator&lt;&lt;</TT> to be a template
function.</P>
<PRE><FONT COLOR="#0066FF">template &lt;class T&gt; ostream&amp; operator&lt;&lt; (ostream&amp;, Array&lt;T&gt;&amp;)
</FONT></PRE>
<P>Now that <TT>operator&lt;&lt;</TT> is a template function, you need only to provide
an implementation. Listing 19.4 shows the <TT>Array</TT> template extended to include
this declaration and provides the implementation for the <TT>operator&lt;&lt;</TT>.


<BLOCKQUOTE>
	<P>
<HR>
<FONT COLOR="#000077"><B>NOTE: </B></FONT>To compile this listing, copy lines 8-26
	of Listing 19.2 and insert them between lines 3 and 4. Also copy lines 51-86 of Listing
	19.2 and insert them between lines 37 and 38. 
<HR>


</BLOCKQUOTE>

<P><A NAME="Heading18"></A><FONT SIZE="4" COLOR="#000077"><B>Listing 19.4. Using
operator ostream.</B></FONT>
<PRE><FONT COLOR="#0066FF">1:     #include &lt;iostream.h&gt;
2:
3:     const int DefaultSize = 10;
4:
5:     template &lt;class T&gt;  // declare the template and the parameter
6:     class Array            // the class being parameterized
7:     {
8:     public:
9:        // constructors
10:       Array(int itsSize = DefaultSize);
11:       Array(const Array &amp;rhs);
12:       ~Array() { delete [] pType; }
13:
14:       // operators
15:       Array&amp; operator=(const Array&amp;);
16:       T&amp; operator[](int offSet) { return pType[offSet]; }
17:       const T&amp; operator[](int offSet) const 
18:        { return pType[offSet]; }
19:       // accessors
20:       int GetSize() const { return itsSize; }
21:
22:       friend ostream&amp; operator&lt;&lt; (ostream&amp;, Array&lt;T&gt;&amp;);
23:
24:    private:
25:       T *pType;
26:       int  itsSize;
27:    };
28:
29:    template &lt;class T&gt;
30:    ostream&amp; operator&lt;&lt; (ostream&amp; output, Array&lt;T&gt;&amp; theArray)
31:    {
32:       for (int i = 0; i&lt;theArray.GetSize(); i++)
33:          output &lt;&lt; &quot;[&quot; &lt;&lt; i &lt;&lt; &quot;] &quot; &lt;&lt; theArray[i] &lt;&lt; endl; return output;
34:    }
35:
36:    enum BOOL { FALSE, TRUE};
37:
38:    int main()
39:    {
40:       BOOL Stop = FALSE;       // flag for looping
41:       int offset, value;
42:       Array&lt;int&gt; theArray;
43:
44:       while (!Stop)
45:       {
46:          cout &lt;&lt; &quot;Enter an offset (0-9) &quot;;
47:          cout &lt;&lt; &quot;and a value. (-1 to stop): &quot; ;
47:          cin &gt;&gt; offset &gt;&gt; value;
48:
49:          if (offset &lt; 0)
50:             break;
51:
52:          if (offset &gt; 9)
53:          {
54:             cout &lt;&lt; &quot;***Please use values between 0 and 9.***\n&quot;;
55:             continue;
56:          }
57:
58:          theArray[offset] = value;
59:       }
60:
61:       cout &lt;&lt; &quot;\nHere's the entire array:\n&quot;;
62:       cout &lt;&lt; theArray &lt;&lt; endl;
63:     return 0;
<TT>64: }</TT></FONT>
<FONT COLOR="#0066FF">
Output: Enter an offset (0-9) and a value. (-1 to stop): 1 10
Enter an offset (0-9) and a value. (-1 to stop): 2 20
Enter an offset (0-9) and a value. (-1 to stop): 3 30
Enter an offset (0-9) and a value. (-1 to stop): 4 40
Enter an offset (0-9) and a value. (-1 to stop): 5 50
Enter an offset (0-9) and a value. (-1 to stop): 6 60
Enter an offset (0-9) and a value. (-1 to stop): 7 70
Enter an offset (0-9) and a value. (-1 to stop): 8 80
Enter an offset (0-9) and a value. (-1 to stop): 9 90
Enter an offset (0-9) and a value. (-1 to stop): 10 10
***Please use values between 0 and 9.***
Enter an offset (0-9) and a value. (-1 to stop): -1 -1

Here's the entire array:
[0] 0
[1] 10
[2] 20
[3] 30
[4] 40
[5] 50
[6] 60
[7] 70
[8] 80
[9] 90
</FONT></PRE>
<P><FONT COLOR="#000077"><B>Analysis:</B></FONT><B> </B>On line 22, the function
template <TT>operator&lt;&lt;()</TT> is declared to be a friend of the <TT>Array</TT>
class template. Because <TT>operator&lt;&lt;()</TT> is implemented as a template
function, every instance of this parameterized array type will automatically have
an <TT>operator&lt;&lt;()</TT>. The implementation for this operator starts on line
29. Every member of an array is called in turn. This only works if there is an <TT>operator&lt;&lt;</TT>
defined for every type of object stored in the array.
<H4 ALIGN="CENTER"><A NAME="Heading20"></A><FONT COLOR="#000077">A Type-Specific
Template Friend Class or Function</FONT></H4>
<P>Although the insertion operator shown in Listing 19.4 works, it is still not quite
what is needed. Because the declaration of the friend operator on line 29 declares
a template, it will work for any instance of <TT>Array</TT> and any insertion operator
taking an array of any type.</P>
<P>The insertion operator template shown in Listing 19.4 makes all instances of the
insertion <TT>operator&lt;&lt;</TT> a friend of any instance of <TT>Array</TT>, whether
the instance of the insertion operator is an integer, an <TT>Animal</TT>, or a <TT>Car</TT>.
It makes no sense, however, for an <TT>Animal</TT> insertion operator to be a friend
to the insertion operator for an integer array.</P>
<P>What is needed is for the insertion operator for an array of <TT>int</TT> to be
a friend to the <TT>Array</TT> of <TT>int</TT> class, and for the insertion operator
of an array of <TT>Animals</TT> to be a friend to the <TT>Array</TT> of animals instance.</P>
<P>To accomplish this, modify the declaration of the insertion operator on line 29
of Listing 19.4, and remove the words <TT>template &lt;class T&gt;</TT>. That is,
change line 30 to read</P>
<PRE><FONT COLOR="#0066FF">friend ostream&amp; operator&lt;&lt; (ostream&amp;, Array&lt;T&gt;&amp;);
</FONT></PRE>
<P>This will use the type (<TT>T</TT>) declared in the template of <TT>Array</TT>.
Thus, the <TT>operator&lt;&lt;</TT> for an integer will only work with an array of
integers, and so forth.
<H3 ALIGN="CENTER"><A NAME="Heading21"></A><FONT COLOR="#000077">Using Template Items</FONT></H3>
<P>You can treat template items as you would any other type. You can pass them as
parameters, either by reference or by value, and you can return them as the return
values of functions, also by value or by reference. Listing 19.5 demonstrates how
to pass template objects.</P>

<P><A NAME="Heading22"></A><FONT SIZE="4" COLOR="#000077"><B>Listing 19.5. Passing
template objects to and from functions.</B></FONT>
<PRE><FONT COLOR="#0066FF">1:     #include &lt;iostream.h&gt;
2:
3:     const int DefaultSize = 10;
4:
5:     // A trivial class for adding to arrays
6:     class Animal
7:     {
8:     public:
9:     // constructors
10:         Animal(int);
11:         Animal();
12:         ~Animal();
13:
14:         // accessors
15:         int GetWeight() const { return itsWeight; }
16:         void SetWeight(int theWeight) { itsWeight = theWeight; }
17: