83: PartNode (Part*): 84: PartNodeO:

85: void SetNext(PartNode * node)

86: { itsNext = node; }

87: PartNode - GetNextO const;

88: Part * GetPartO const;

89: private:

90; Part .itsPart;

91; PartNode * itsNext;

92: } ;

95; PartNode:;PartNode(Part* pPart):

96: itsPart(pPart),

97: itsNext(O)

98: { }

100; PartNode: : PartNodeO 101: {

102: delete itsPart;

103: itsPart = 0;

104: delete itsNext; 105: itsNext = 0;

106: }

107:

108: Возвращается NULL, если нет следующего узла PartNode

109: PartNode PartNode::GetNext() const

110: {

111: return itsNext;

112: }

113:

114: Part . PartNode: :GetPartO const

115: {

116: if (itsPart)

117: return itsPart;

118: else

119: return NULL; ошибка

120; }

121: 122:

123: .............. Класс Part List ............

124: class PartsList

125: {

126: public:

127: PartsListO;

128: PartsListO;

129: Необходимо, чтобы конструктор-копировщик и оператор соответствовали друг другу!

130: void Iterate(void (Part::.f)()const) const: 131: Part* Find(int & position, int PartNumber) const;

Part* GetFirstO const; void Insert(Part *); Part* operator[](int) const; int GetCountO const { return itsCount; } static PartsList* GetGlobalPartsListO {

return GlobalPartsList;

private: PartNode * pHead; int itsCount;

static PartsList GlobalPartsList; } :

PartsList PartsList:;GlobalPartsList;

Implementations for Lists...

PartsList::PartsList(): pHead(O), itsCount(O) { }

PartsList:: PartsList() {

delete pHead;

Part* PartsList::GetFirst() const {

if (pHead)

return pHead->itsPart; else

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

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

PartNode* pNode = pHead;

if (IpHead)

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

if (OffSet > itsCount) return NULL; ошибка

for (int i=0;i<offSet; i++) pNode = pNode->itsNext;

return pNode->itsPart;

182; } 183:

184: Part* PartsList::Find(lnt & position, int 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 (IpHead)

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: int New = pPart->GetPartNumber(); 217: int Next = 0; 218: itsCount++; 219:

220: if (!pHead) 221: {

222: pHead = pNode;

223: return;

224: } 225:

226: если это значение меньше головного узла, 227: то текущий узел становится головным 228: if (pHead->itsPart->GetPartNumber() > New) 229: {

230: pNode->itsNext = pHead;

231: pHead = pNode;