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

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

129:

130: template <class T>

131: class Node

132: {

133: public:

134: friend class List<T>;

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 <class T>

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

149: itsObject(pOjbect),

150: itsNext(0)

151: { }

152:

153: template <class T>

154: Node<T>::~Node

155: {

156: delete its0bject;

157: itsObject = 0;

158: delete itsNext;

159: itsNext = 0;

160: }

161:

162: //

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

163: template <class T>

164: Node<T> * Node<T>::GetNext const

165: {

166: return itsNext;

167: }

168:

169: template <class T>

170: T * Node<T>::GetObject const

171: {

172: if (itsObject)

173: return itsObject;

174: else

175: throw NullNode;

176: }

177:

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

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

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

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

182: template <olass T>

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<T> * pHead;

196: int itsCount;

197: };

198:

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

200: template <class T>

201: List<T>::List;

202: pHead(0),

203: itsCount(0)

204: { }

205:

206: template <class T>

207: List<T>::~List

208: {

209: delete pHead;

210: }

211:

212: template <class T>

213: T* List<T>::GetFirst const

214: {

215: if (pHead)

216: return pHead->itsObject;

217: else

218: throw EmptyList;

219: }

220:

221: template <class T>

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

223: {

224: Node<T>* pNode = pHead;

225:

226: if (!pHead)

227: throw EmptyList;

228:

229: if (offSet > itsCount)

230: throw BoundsError;

231:

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

233: pNode = pNode->itsNext;

234:

235: return pNode->itsObject;

236: }

237:

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

239: template <class T>

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

241: {

242: Node<T> * 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 <class T>

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

259: {

260: Node<T> * pNode = new Node<T>(p0bject);

261: Node<T> * pCurrent = pHead;

262: Node<T> * 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: // если данный объект больше текущего, но меньше следующего,