Освой самостоятельно С++ за 21 день.

Либерти Джесс

155:

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

157:

158: PartsList::PartsList:

159: pHead(0),

160: itsCount(0)

161: { }

162:

163: PartsList::^PartsList

164: {

165: delete pHead;

166: }

167:

168: Part* PartsList::GetFirst const

169: {

170: if (pHead)

171: return pHead->GetPart;

172: else

173: return NULL; // ловушка

ошибок

174: }

175:

176: Part * PartsList::operator[](int offSet) const

177: {

178: PartNode* pNode = pHead;

179:

180: if (!pHead)

181: return NULL; // ловушка ошибок

182:

183: if (offSet > itsCount)

184: return NULL; // ошибка

185:

186: for (int i=0;i<offSet; i++)

187: pNode = pNode->GetNext;

188:

189: return pNode->GetPart;

190: }

191:

192: Part* PartsList::Find(int & position, int PartNumber) const

193: {

194: PartNode * pNode = 0;

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

196: pNode!=NULL;

197: pNode = pNode->GetNext, position++)

198: {

199: if (pNode->GetPart->GetPartNumber == PartNumber)

200: break;

201: }

202: if (pNode == NULL)

203: return NULL;

204: else

205: return pNode->GetPart;

206: }

207:

208: void PartsList::Iterate(void (Part::*func)const) const

209: {

210: if (!pHead)

211: return;

212: PartNode* pNode = pHead;

213: do

214: (pNode->GetPart->*func);

215: while (pNode = pNode->GetNext);

216: }

217:

218: void PartsList::Insert(Part* pPart)

219: {

220: PartNode * pNode = new PartNode(pPart);

221: PartNode * pCurrent = pHead;

222: PartNode >> pNext = 0;

223:

224: int New = pPart->GetPartNumber;

225: int Next = 0;

226: itsCount++;

227:

228: if (!pHead)

229: {

230: pHead = pNode;

231: return;

232: }

233:

234: // Если это значение меньше головного узла,

235: // то текущий узел становится головным

236: if (pHead->GetPart->GetPartNumber->New)

237: {

238: pNode->SetNext(pHead);

239: pHead = pHode;

240: return;

241: }

242:

243: for (;;)

244: {

245: // Если нет следующего, вставляется текущий

246: if (!pCurrent->GetNext)

247: {

248: pCurrent->SetNext(pNode);

249: return;

250: }

251:

252: // Если текущий больше предыдущего, но меньше следующего, то вставляем

253: // здесь. Иначе присваиваем значение указателя Next

254: pNext = pCurrent->GetNext;

255: Next = pNext->GetPart->GetPartNumber;

256: if (Next > New)

257: {

258: pCurrent->SetNext(pNode);

259: pNode->SetNext(pNext);

260: return;

261: }

262: pCurrent = pNext;

263: }

264: }

265:

266: int main

267: {

268: PartsList&pl = PartsList::GetGlobalPartsList;

269: Part * pPart = 0;

270: int PartNumber;

271: int value;

272: int Choice;

273:

274: while (1)

275: {

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

277: cin >> choice;

278:

279: if (!choice)

280: break;

281:

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

283: cin >> PartNumber;

284:

285: if (choice == 1)

286: {

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

288: cin >> value;

289: pPart = new CarPart(value,PartNumber);

290: }

291: else

292: {

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

294: cin >> value;

295: pPart = new AirPlanePart(value,PartNumber);

296: }

297:

298: pl.Insert(pPart);

299: }

300: void (Part::*pFunc)const = Part::Display;

301: pl.Iterate(pFunc);

302: return 0;

303: }

Результат:

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

New PartNumber?: 2837

Model Year? 90

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

New PartNumber?: 378

Engine Number?: 4938

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

New PartNumber?: 4499

Model Year?: 94

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

New PartNumber?: 3000

Model Year? 93

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

Part Number: 378

Engine No.: 4938

Part Number: 2837

Model Year: 90

Part Number: 3000

Model Year: 93

Part Number: 4499