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

73:

74: // *************** Узлы списка деталей **********

75: class PartNode

76: {

77: public:

78: PartNode (Part*);

79: ~PartNode;

80: void SetNext(PartNode * node)

81: { itsNext = node; }

82: PartNode * GetNext const;

83: Part * GetPart const;

84: private:

85: Part *itsPart;

86: PartNode * itsNext;

87: };

88: // Выполнение PartNode...

89:

90: PartNode::PartNode(Part* pPart):

91: itsPart(pPart),

92: itsNext(0)

93: { }

94:

95: PartNode::~PartNode

96: {

97: delete itsPart;

98: itsPart = 0;

99: delete itsNext;

100: itsNext = 0;

101: }

102:

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

104: PartNode * PartNode::GetNext const

105: {

106: return itsNext;

107: }

108:

109: Part * PartNode::GetPart const

110: {

111: if (itsPart)

112: return itsPart;

113: else

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

115: }

116:

117:

118:

119: // **************** Список деталей ***********

120: class PartsList

121: {

122: public:

123: PartsList;

124: ~PartsList;

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

126: void Iterate(void (Part::*f)const) const;

127: Part* Find(int & position, int PartNumber) const;

128: Part* GetFirst const;

129: void Insert(Part *);

130: Part* operator[](int) const;

131: int GetCount const { return itsCount;}

132: static PartsList& GetGlobalPartsList

133: {

134: return GiobalPartsList;

135: }

136: private:

137: PartNode * pHead;

138: int itsCount;

139: static PartsList GiobalPartsList;

140: };

141:

142: PartsList PartsList::GlobalPartsList;

143:

144:

145: PartsList::PartsList:

146: pHead(0),

147: itsCount(0)

148: { }

149:

150: PartsList::~PartsList

151: {

152: delete pHead;

153: }

154:

155: Part* PartsList::GetFirst const

156: {

157: if (pHead)

158: return pHead->GetPart;

159: else

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

161: }

162:

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

164: {

165: PartNode* pNode = pHead;

166:

167: if (!pHead)

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

169:

170: if (offSet > itsCount)

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

172:

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

174: pNode = pNode->GetNext;

175:

176: return pNode->GetPart;

177: }

178:

179: Part* PartsList::Find(

180: int & position,

181: int PartNumber) const

182: {

183: PartNode * pNode = 0;

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

185: pNode!=NULL;

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

187: {

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

189: break;

190: }

191: if (pNode == NULL)

192: return NULL;

193: else

194: return pNode->GetPart;

195: }

196:

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

198: {

199: if (!pHead)

200: return;

201: PartNode* pNode = pHead;

202: do

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

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

205: }

206:

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

208: {

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

210: PartNode * pCurrent - pHead;

211: PartNode * pNext = 0;

212:

213: int New = pPart->GetPartNumber;

214: int Next = 0;

215: itsCount++;

216:

217: if (!pHead)

218: {

219: pHead = pNode;

220: return;

221: }

222:

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

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

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

226: {

227: pNode->SetNext(pHead);

228: pHead = pNode;

229: return;

230: }

231:

232: for (;;)

233: {

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

235: if (!pCurrent->GetNext)

236: {

237: pCurrent->SetNext(pNode);

238: return;

239: }

240:

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

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

243: pNext = pCurrent->GetNext;

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

245: if (Next > New)

246: {

247: pCurrent->SetNext(pNode);

248: pNode->SetNext(pNext);

249: return;

250: }

251: pCurrent = pNext;

252: }

253: }

254:

255:

256:

257: class PartsCatalog