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

Листинг 15.7. Использование классов-друзей

1: #include

2:

3:

4:

5:

6: // **************** Класс Part ************

7:

8: // Абстрактный базовый класс всех деталей

9: class Part

10: {

11: public:

12: Part():itsPartNumber(1) { }

13: Part(int PartNumber):

14: itsPartNumber(PartNumber){ }

15: virtual ~Part(){ }

16: int GetPartNumber() const

17: { return itsPartNumber; }

18: virtual void Display() const =0;

19: private:

20: int itsPartNumber;

21: };

22:

23: // выполнение чистой виртуальной функции в

24: // стандартном виде для всех производных классов

25: void Part::Display() const

26: {

27: cout << "\nPart Number: ";

28: cout << itsPartNumber << endl;

29: }

30:

31: // ************** Класс Car Part ************

32:

33: class CarPart : public Part

34: {

35: public:

36: CarPart():itsModelYear(94){ }

37: CarPart(int year, int partNumber);

38: virtual void Display() const

39: {

40: Part::Display();

41: cout << "Model Year: ";

42: cout << itsModelYear << endl;

43: }

44: private:

45: int itsModelYear;

46: };

47:

48: CarPart::CarPart(int year, int partNumber):

49: itsModelYear(year),

50: Part(partNumber)

51: { }

52:

53:

54: // *********** Класс AirPlane Part ***********

55:

56: class AirPlanePart : public Part

57: {

58: public:

59: AirPlanePart():itsEngineNumber(1){ };

60: AirPlanePart

61: (int EngineNumber, int PartNumber);

62: virtual void Display() const

63: {

64: Part::Display();

65: cout << "Engine No.: ";

66: cout << itsEngineNumber << endl;

67: }

68: private:

69: int itsEngineNumber;

70: };

71:

72: AirPlanePart::AirPlanePart

73: (int EngineNumber, int PartNumber):

74: itsEngineNumber(EngineNumber),

75: Part(PartNumber)

76: { }

77:

78: // **************** Класс Part Node ************

79: class PartNode

80: {

81: public:

82: friend class PartsList;

83: PartNode (Part*);

84: ~PartNode();

85: void SetNext(PartNode * node)

86: { itsNext = node; }

87: PartNode * GetNext() const;

88: Part * GetPart() const;

89: private:

90: Part *itsPart;

91: PartNode * itsNext;

92: };

93:

94:

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

96: itsPart(pPart),

97: itsNext(0)

98: { }

99:

100: PartNode::~PartNode()

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::GetPart() 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: PartsList();

128: ~PartsList();

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

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

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

132: Part* GetFirst() const;

133: void Insert(Part *);

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

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

136: static PartsList& GetGlobalPartsList()

137: {

138: return GiobalPartsList;

139: }

140: private:

141: PartNode * pHead;

142: int itsCount;

143: static PartsList GiobalPartsList;

144: };

145:

146: PartsList PartsList::GlobalPartsList;

147:

148: // Implementations for Lists...

149:

150: PartsList::PartsList();

151: pHead(0),

152: itsCount(0)

153: { }

154:

155: PartsList::~PartsList()

156: {

157: delete pHead;

158: }

159:

160: Part* PartsList::GetFirst() const

161: {

162: if (pHead)

163: return pHead->itsPart;

164: else

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

166: }

167:

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

169: {

170: PartNode* pNode = pHead;

171:

172: if (!pHead)

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

174:

175: if (offSet > itsCount)

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

177:

178: for (int i=0;i

179: pNode = pNode->itsNext;

180:

181: return pNode->itsPart;

182: }

183:

184: Part* PartsList::Find(int & 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 (!pHead)

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;

232: return;

233: }

234:

235: for (;;)

236: {

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

238: if (!pCurrent->itsNext)

239: {

240: pCurrent->itsNext = pNode;

241: return;

242: }

243:

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

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

246: pNext = pCurrent->itsNext;

247: Next = pNext->itsPart->GetPartNumber();

248: if (Next > New)

249: {

250: pCurrent->itsNext = pNode;

251: pNode->itsNext = pNext;

252: return;

253: }

254: pCurrent = pNext;

255: }

256: }

257:

258: class PartsCatalog : private PartsList

259: {

260: public:

261: void Insert(Part *);

262: int Exists(int PartNumber);

263: Part * Get(int PartNumber);

264: operator+(const PartsCatalog &);

265: void ShowAll() { Iterate(Part::Display); }

266: private:

267: };

268:

269: void PartsCatalog::Insert(Part * newPart)