Джесс Либерти - Освой самостоятельно С++ за 21 день.

117: {

118: Part::Display();

119: cout << "Engine No,: " << itsEngineNumber << endl;

120: }

121:

122: // Обьявление класса List

123: template

124: class List;

125:

126: // **************** Node ************

127: // Общий узел, который можно добавить к списку

128: // **********************************

129:

130: template

131: class Node

132: {

133: public:

134: friend class List;

135: Node (T*);

136: ~Node();

137: void SetNext(Node * node) { itsNext = node; }

138: Node * GetNext() const;

139: T * GetObject() const;

140: private:

141: T* its0bject;

142: Node * itsNext;

143: };

144:

145: // Выполнение узла...

146:

147: template

148: Node::Node(T* p0jbect):

149: itsObject(pOjbect),

150: itsNext(0)

151: { }

152:

153: template

154: Node::~Node()

155: {

156: delete its0bject;

157: itsObject = 0;

158: delete itsNext;

159: itsNext = 0;

160: }

161:

162: // Возвращает значение NULL, если нет следующего узла

163: template

164: Node * Node::GetNext() const

165: {

166: return itsNext;

167: }

168:

169: template

170: T * Node::GetObject() const

171: {

172: if (itsObject)

173: return itsObject;

174: else

175: throw NullNode();

176: }

177:

178: // **************** List ************

179: // Общий шаблон списка

180: // Работает с любым нумерованным объектом

181: // **********************************

182: template

183: class List

184: {

185: public:

186: List();

187: ~List();

188:

189: T* Find(int & position, int 0bjectNumber) const;

190: T* GetFirst() const;

191: void Insert(T *);

192: T* operator[](int) const;

193: int GetCount() const { return itsCount; }

194: private:

195: Node * pHead;

196: int itsCount;

197: };

198:

199: // Выполнение списка...

200: template

201: List::List();

202: pHead(0),

203: itsCount(0)

204: { }

205:

206: template

207: List::~List()

208: {

209: delete pHead;

210: }

211:

212: template

213: T* List::GetFirst() const

214: {

215: if (pHead)

216: return pHead->itsObject;

217: else

218: throw EmptyList();

219: }

220:

221: template

222: T * List::operator[](int offSet) const

223: {

224: Node* pNode = pHead;

225:

226: if (!pHead)

227: throw EmptyList();

228:

229: if (offSet > itsCount)

230: throw BoundsError();

231:

232: for (int i=0;i

233: pNode = pNode->itsNext;

234:

235: return pNode->itsObject;

236: }

237:

238: // Находим данный обьект в списке на основе его идентификационного номера (id)

239: template

240: T* List::Find(int & position, int 0bjectNumber) const

241: {

242: Node * pNode = 0;

243: for (pNode = pHead, position = 0;

244: pNode!=NULL;

245: pNode = pNode->itsNext, position++)

246: {

247: if (pNode->itsObject->GetObjectNumber() == 0bjectNumber)

248: break;

249: }

250: if (pNode == NULL)

251: return NULL;

252: else

253: return pNode->itsObject;

254: }

255:

256: // добавляем в список, если номер объекта уникален

257: template

258: void List::Insert(T* pObject)

259: {

260: Node * pNode = new Node(p0bject);

261: Node * pCurrent = pHead;

262: Node * pNext = 0;

263:

264: int New = p0bject->Get0bjectNumber();

265: int Next = 0;

266: itsCount++;

267:

268: if (!pHead)

269: {

270: pHead = pNode;

271: return;

272: }

273:

274: // если номер текущего объекта меньше номера головного,

275: // то этот объект становится новым головным узлом

276: if (pHead->itsObject->GetObjectNumber() > New)

277: {

278: pNode->itsNext = pHead;

279: pHead = pNode;

280: return;

281: }

282:

283: for (;;)

284: {

285: // если нет следующего обьекта, добавляем в конец текущий объект

286: if (!pCurrent->itsNext)

287: {

288: pCurrent->itsNext = pNode;

289: return;

290: }

291:

292: // если данный объект больше текущего, но меньше следующего,

293: // то вставляем его между ними, в противном случае переходим к следующему объекту

294: pNext = pCurrent->itsNext;

295: Next = pNext->itsObject->GetObjectNumber();

296: if (Next > New)

297: {

298: pCurrent->itsNext = pNode;

299: pNode->itsNext = pNext;

300: return;

301: }

302: pCurrent = pNext;

303: }

304: }

305:

306:

307: int main()

308: {

309: List theList;

310: int choice;

311: int ObjectNumber;

312: int value;

313: Part * pPart;

314: while (1)

315: {

316: cout << "(0)Quit (1)Car (2)Plane: ";

317: cin >> choice;

318:

319: if (!choice)

320: break;

321:

322: cout << " New PartNumber?: ";

323: cin >> ObjectNumber;

324:

325: if (choice == 1)

326: {

327: cout << "Model Year?: ";

328: cin >> value;

329: try

330: {

331: pPart = new CarPart(value,ObjectNumber);

332: }

333: catch (OutOfMemory)

334: {

335: cout << "Not enough memory; Exiting..." << endl;

336: return 1;

337: }

338: }

339: else

340: {

341: cout << "Engine Number?: ";

342: cin >> value;

343: try

344: {

345: pPart = new AirPlanePart(value,ObjectNumber);

346: }

347: catch (OutOfMemory)

348: {

349: cout << "Not enough memory: Exiting..." << endl;

350: return 1;

351: }

352: }

353: try

354: {

355: theList.Insert(pPart);

356: }

357: catch (NullNode)

358: {

359: cout << "The list is broken, and the node is null!" << endl;

360: return 1;

361: }

362: catch (EmptyList)

363: {

364: cout << "The list is empty!" << endl;

365: return 1;

366: }

367: }

368: try

369: {

370: for (int i = 0; i < theList.GetCount(); i++ )

371: cout << *(theList[i]);

372: }

373: catch (NullNode)

374: {

375: cout << "The list is broken, and the node is null!" << endl;

376: return 1;

377: }

378: catch (EmptyList)

379: {

380: cout << "The list is empty!" << endl;

381: return 1;

382: }

383: catch (BoundsError)

384: {

385: cout << "Tried to read beyond the end of the list!" << endl;

386: return 1;

387: }

388: return 0;

389: }

Результат:

(0)Quit (1)Car (2)Plane: 1

New PartNumber?: 2837

Model Year? 90

(0)Quit (1)Car (2)Plane: 2

New PartNumber?: 378