ch15.htm

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

69:          USHORT itsEngineNumber;
70:       };
71:     
72:       AirPlanePart::AirPlanePart
73:           (USHORT EngineNumber, ULONG PartNumber):
74:          itsEngineNumber(EngineNumber),
75:          Part(PartNumber)
76:       {}
77:     
78:     // **************** Part Node ************
79:     class PartNode
80:     {
81:     public:
82:        friend class PartsList;
83:        PartNode (Part*);
84:        ~PartNode();
85:        void SetNext(PartNode * node) 
86:            { itsNext = node; }
87:        PartNode * GetNext() const;
88:        Part * GetPart() const;
89:     private:
90:        Part *itsPart;
91:        PartNode * itsNext;
92:     };
93:    
94:       
95:          PartNode::PartNode(Part* pPart):
96:          itsPart(pPart),
97:          itsNext(0)
98:          {}
99:       
100:          PartNode::~PartNode()
101:          {
102:              delete itsPart;
103:              itsPart = 0;
104:              delete itsNext;
105:              itsNext = 0;
106:           }
107:        
108:           // Returns NULL if no next PartNode
109:           PartNode * PartNode::GetNext() const
110:           {
111:                 return itsNext;
112:           }
113:        
114:           Part * PartNode::GetPart() const
115:           {
116:              if (itsPart)
117:                 return itsPart;
118:              else
119:                 return NULL; //error
120:           }
121:        
122:    
123:     // **************** Part List ************
124:     class PartsList
125:     {
126:     public:
127:        PartsList();
128:        ~PartsList();
129:        // needs copy constructor and operator equals!
130:        void     Iterate(void (Part::*f)()const) const;
131:        Part*    Find(ULONG & position, ULONG PartNumber) const;
132:        Part*    GetFirst() const;
133:        void       Insert(Part *);
134:        Part*    operator[](ULONG) const;
135:        ULONG    GetCount() const { return itsCount; }
136:        static    PartsList& GetGlobalPartsList() 
137:                { 
138:                    return  GlobalPartsList;
139:                }
140:     private:
141:        PartNode * pHead;
142:        ULONG itsCount;
143:        static PartsList GlobalPartsList;
144:     };
145:    
146:     PartsList PartsList::GlobalPartsList;
147:    
148:     // Implementations for Lists...
149:    
150:     PartsList::PartsList():
151:        pHead(0),
152:        itsCount(0)
153:        {}
154:    
155:     PartsList::~PartsList()
156:     {
157:        delete pHead;
158:     }
159:    
160:     Part*   PartsList::GetFirst() const
161:     {
162:        if (pHead)
163:           return pHead->itsPart;
164:        else
165:           return NULL;  // error catch here
166:     }
167:    
168:     Part * PartsList::operator[](ULONG offSet) const
169:     {
170:        PartNode* pNode = pHead;
171:    
172:        if (!pHead)
173:           return NULL; // error catch here
174:    
175:        if (offSet > itsCount)
176:           return NULL; // error
177:    
178:        for (ULONG i=0;i<offSet; i++)
179:           pNode = pNode->itsNext;
180:    
181:       return   pNode->itsPart;
182:     }
183:    
184:    Part* PartsList::Find(ULONG & position, ULONG PartNumber) const
185:     {
186:        PartNode * pNode = 0;
187:        for (pNode = pHead, position = 0;
188:              pNode!=NULL;
189:              pNode = pNode->itsNext, position++)
190:        {
191:           if (pNode->itsPart->GetPartNumber() == PartNumber)
192:              break;
193:        }
194:        if (pNode == NULL)
195:           return NULL;
196:        else
197:           return pNode->itsPart;
198:     }
199:    
200:     void PartsList::Iterate(void (Part::*func)()const) const
201:     {
202:        if (!pHead)
203:           return;
204:        PartNode* pNode = pHead;
205:        do
206:           (pNode->itsPart->*func)();
207:        while (pNode = pNode->itsNext);
208:     }
209:    
210:     void PartsList::Insert(Part* pPart)
211:     {
212:        PartNode * pNode = new PartNode(pPart);
213:        PartNode * pCurrent = pHead;
214:        PartNode * pNext = 0;
215:    
216:        ULONG New =  pPart->GetPartNumber();
217:        ULONG Next = 0;
218:        itsCount++;
219:    
220:        if (!pHead)
221:        {
222:           pHead = pNode;
223:           return;
224:        }
225:    
226:        // if this one is smaller than head
227:        // this one is the new head
228:        if (pHead->itsPart->GetPartNumber() > New)
229:        {
230:           pNode->itsNext = pHead;
231:           pHead = pNode;
232:           return;
233:        }
234:    
235:        for (;;)
236:        {
237:           // if there is no next, append this new one
238:           if (!pCurrent->itsNext)
239:           {
240:              pCurrent->itsNext = pNode;
241:              return;
242:           }
243: 
244:           // if this goes after this one and before the next
245:           // then insert it here, otherwise get the next
246:           pNext = pCurrent->itsNext;
247:           Next = pNext->itsPart->GetPartNumber();
248:           if (Next > New)
249:           {
250:              pCurrent->itsNext = pNode;
251:              pNode->itsNext = pNext;
252:              return;
253:           }
254:           pCurrent = pNext;
255:        }
256:     }
257:    
258:     class PartsCatalog : private PartsList
259:     {
260:     public:
261:        void Insert(Part *);
262:        ULONG Exists(ULONG PartNumber);
263:        Part * Get(int PartNumber);
264:        operator+(const PartsCatalog &);
265:        void ShowAll() { Iterate(Part::Display); }
266:     private:
267:     };
268:    
269:     void PartsCatalog::Insert(Part * newPart)
270:     {
271:        ULONG partNumber =  newPart->GetPartNumber();
272:        ULONG offset;
273:    
274:        if (!Find(offset, partNumber))
275:           PartsList::Insert(newPart);
276:        else
277:        {
278:           cout << partNumber << " was the ";
279:           switch (offset)
280:           {
281:              case 0:  cout << "first "; break;
282:              case 1:  cout << "second "; break;
283:              case 2:  cout << "third "; break;
284:              default: cout << offset+1 << "th ";
285:           }
286:           cout << "entry. Rejected!\n";
287:        }
288:     }
289:    
290:     ULONG PartsCatalog::Exists(ULONG PartNumber)
291:     {
292:        ULONG offset;
293:        Find(offset,PartNumber);
294:        return offset;
295:     }
296:    
297:     Part * PartsCatalog::Get(int PartNumber)
298:     {
299:        ULONG offset;
300:        return (Find(offset, PartNumber));
301:    
302:     }
303:    
304:     int main()
305:     {
306:        PartsCatalog pc;
307:        Part * pPart = 0;
308:        ULONG PartNumber;
309:        USHORT value;
310:        ULONG choice;
311:    
312:        while (1)
313:        {
314:           cout << "(0)Quit (1)Car (2)Plane: ";
315:           cin >> choice;
316:    
317:           if (!choice)
318:              break;
319:    
320:           cout << "New PartNumber?: ";
321:           cin >>  PartNumber;
322:    
323:           if (choice == 1)
324:           {
325:              cout << "Model Year?: ";
326:              cin >> value;
327:              pPart = new CarPart(value,PartNumber);
328:           }
329:           else
330:           {
331:              cout << "Engine Number?: ";
332:              cin >> value;
333:              pPart = new AirPlanePart(value,PartNumber);
334:           }
335:           pc.Insert(pPart);
336:        }
337:        pc.ShowAll();
338:       return 0;
<TT>339: }</TT></FONT>
<FONT COLOR="#0066FF">
Output: (0)Quit (1)Car (2)Plane:  1
New PartNumber?: 1234
Model Year?: 94
(0)Quit (1)Car (2)Plane:  1
New PartNumber?: 4434
Model Year?: 93
(0)Quit (1)Car (2)Plane:  1
New PartNumber?: 1234
Model Year?: 94
1234 was the first entry. Rejected!
(0)Quit (1)Car (2)Plane:  1
New PartNumber?: 2345
Model Year?: 93
(0)Quit (1)Car (2)Plane:  0

Part Number: 1234
Model Year: 94

Part Number: 2345
Model Year: 93

Part Number: 4434
Model Year: 93
</FONT></PRE>
<P><FONT COLOR="#000077"><B>Analysis:</B></FONT><B> </B>On line 82, the class <TT>PartsList</TT>
is declared to be a friend to the <TT>PartNode</TT> class. Because <TT>PartsList</TT>
has not yet been declared, the compiler would complain that this type is not known.</P>
<P>This listing places the friend declaration in the public section, but this is
not required; it can be put anywhere in the class declaration without changing the
meaning of the statement. Because of this statement, all the private member data
and functions are available to any member function of class <TT>PartsList</TT>.</P>
<P>On line 160, the implementation of the member function <TT>GetFirst()</TT> reflects
this change. Rather than returning <TT>pHead-&gt;GetPart</TT>, this function can
now return the otherwise private member data by writing <TT>pHead-&gt;itsPart</TT>.
Similarly, the <TT>Insert()</TT> function can now write <TT>pNode-&gt;itsNext = pHead</TT>,
rather than writing <TT>pNode-&gt;SetNext(pHead)</TT>.</P>
<P>Admittedly these are trivial changes, and there is not a good enough reason to
make <TT>PartsList</TT> a friend of <TT>PartNode</TT>, but they do serve to illustrate
how the keyword <TT>friend</TT> works.</P>
<P>Declarations of friend classes should be used with extreme caution. If two classes
are inextricably entwined, and one must frequently access data in the other, there
may be good reason to use this declaration. But use it sparingly; it is often just
as easy to use the public accessor methods, and doing so allows you to change one
class without having to recompile the other.


<BLOCKQUOTE>
	<P>
<HR>
<FONT COLOR="#000077"><B>NOTE:</B></FONT><B> </B>You will often hear novice C++ programmers
	complain that friend declarations &quot;undermine&quot; the encapsulation so important
	to object-oriented programming. This is, frankly, errant nonsense. The friend declaration
	makes the declared friend part of the class interface, and is no more an undermining
	of encapsulation than is public derivation. 
<HR>


</BLOCKQUOTE>

<H3 ALIGN="CENTER"><A NAME="Heading27"></A><FONT COLOR="#000077">Friend Class</FONT></H3>
<P>Declare one class to be a friend of another by putting the word <TT>friend</TT>
into the class granting the access rights. That is, I can declare you to be my friend,
but you can't declare yourself to be my friend. Example:</P>
<PRE><FONT COLOR="#0066FF">class PartNode{
public:
friend class PartList;  // declares PartList to be a friend of PartNode
};
</FONT></PRE>
<H3 ALIGN="CENTER"><A NAME="Heading28"></A><FONT COLOR="#000077">Friend Fun