ch15.htm

good book for learning c++ standard language

37:          CarPart(USHORT year, ULONG partNumber);
38:          virtual void Display() const 
39:          { 
40:              Part::Display(); 
41:              cout << "Model Year: ";
42:              cout << itsModelYear << endl;  
43:          }
44:       private:
45:          USHORT itsModelYear;
46:       };
47:     
48:       CarPart::CarPart(USHORT year, ULONG partNumber):
49:          itsModelYear(year),
50:          Part(partNumber)
51:       {}
52:     
53: 
54:       // **************** AirPlane Part ************
55:     
56:       class AirPlanePart : public Part
57:       {
58:       public:
59:          AirPlanePart():itsEngineNumber(1){};
60:          AirPlanePart
61:              (USHORT EngineNumber, ULONG PartNumber);
62:          virtual void Display() const
63:          { 
64:              Part::Display(); 
65:              cout << "Engine No.: ";
66:              cout << itsEngineNumber << endl;  
67:          }
68:       private:
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, a