模板参数

1. 用模板函数实现stack

   
   

2. #include <iostream>

3. using namespace std;

4. template<typename T>

5. class Seqlist

6. {

7. private:

8. T *_data;

9. int _size;

10. int _capacity;

11. public:

12. Seqlist()

13. :_size(0), _capacity(3), _data(0)

14. {

15. _data = new T[_capacity];

16. }

17. ~Seqlist()

18. {

19. if (_data != NULL)

20. delete[] _data;

21. _data = NULL;

22. }

23. void Checkcapacity()

24. {

25. if (_size == _capacity)

26. {

27. T *tmp = new T[2 * _capacity + 3];

28. memcpy(tmp, _data, _size*sizeof(T));

29. delete _data;

30. _data = NULL;

31. _data = tmp;

32. _capacity = 2 * _capacity + 3;

33. }

34. }

35. Seqlist(const Seqlist&s)

36. {

37. _data = new T[s._capacity];

38. _size = s._size;

39. _capacity = s._capacity;

40. memcpy(_data, s._data, _capacity*sizeof(T));

41. 
    

42. }

43. Seqlist &operator=(const Seqlist&s)

44. {

45. if (this != &s)

46. {

47. delete[]_data;

48. _data = new T[s._capacity];

49. _size = s._size;

50. _capacity = s._capacity;

51. memcpy(_data, s._data, _capacity*sizeof(T));

52. }

53. return *this;

54. }

55. void PushBack(const T&d)

56. {

57. Checkcapacity();

58. *(_data + _size) = d;

59. _size++;

60. }

61. void  PopBack()

62. {

63. _size--;

64. }

65. void PushFront(const T&d)

66. {

67. 
    

68. Checkcapacity();

69. int i = 0;

70. for (i = _size; i > 0; i--)

71. {

72. *(_data + i) = *(_data + i - 1);

73. }

74. *_data = d;

75. _size++;

76. }

77. void PopFront()

78. {

79. int i = 0;

80. for (i = 0; i < _size - 1; i++)

81. *(_data + i) = *(_data + i + 1);

82. _size--;

83. }

84. void Insert(int pos, const T&d);

85. void Sort()

86. {

87. T tmp = 0;

88. int i = 0;

89. int j = 0;

90. for (i = 0; i < _size - 1; i++)

91. for (j = i + 1; j < _size; j++)

92. {

93. if (*(_data + i) >*(_data + j))

94. {

95. tmp = *(_data + i);

96. *(_data + i) = *(_data + j);

97. *(_data + j) = tmp;

98. }

99. }

100. }

101. void print()

102. {

103. int i = 0;

104. for (i = 0; i < _size; i++)

105. cout << *(_data + i) << " ";

106. }

107. 
     

108. };

109. template<typename T>

110. void Seqlist<T>::Insert(int pos, const T&d)

111. {

112. Checkcapacity();

113. int i = 0;

114. for (i = _size; i>pos; i--)

115. *(_data + i) = *(_data + i - 1);

116. *(_data + pos) = d;

117. _size++;

118. }

119. template <typename T,typename Container=Seqlist <T> >

120. class Stack

121. {

122. private:

123. Container con;

124. public:

125. void Push(const T&d)

126. {

127. con.PushBack(d);

128. }

129. void Pop()

130. {

131. con.PopBack();

132. }

133. void print()

134. {

135. con.print();

136. }

137. };

138. int main()

139. {

140. Stack<int, Seqlist<int> >stack1;

141. stack1.Push(1);

142. stack1.Push(2);

143. stack1.Push(3);

144. stack1.Push(4);

145. stack1.print();

146. getchar();

147. return 0;

148. }

149. 2.运用stack

150. #include <iostream>

151. #include <stack>

152. using namespace std;

153. int main()

154. {

155. stack<int>s;

156. s.push(1);

157. s.push(2);

158. s.push(3);

159. return 0;

160. }

161. 3.模板的模板参数

162. template<typename T,template<class> class Container=Seqlist >

163. class Stack

164. {

165. private:

166. Container<T> con;

167. public:

168. void Push(const T&d)

169. {

170. con.PushBack(d);

171. }

172. void Pop()

173. {

174. con.PopBack();

175. }

176. void print()

177. {

178. con.print();

179. }

180. };

181. int main()

182. {

183. Stack<int>s;

184. s.Push(1);

185. s.Push(2);

186. s.Push(3);

187. s.print();

188. getchar();

189. return 0;

190. }

191. 4.非类型的类模板参数

192. template <typename T,int MAX_SIZE=10>

193. class Seqlist

194. {

195. private:

196. T data[MAX_SIZE];

197. //public:

198. // void show( int a)

199. // {

200. // cout << "show()" << endl;

201. // }

202. };

203. //template <typename T, int MAX_SIZE = 10>

204. //void Seqlist<T, MAX_SIZE>::show(int a)

205. //{

206. // cout << "show()" << endl;

207. //}

208. int main()

209. {

210. Seqlist<int, 10>s1;

211. Seqlist <int, 20>s2;

212. getchar();

213. return 0;

214. }

215. 5.非类型的模板函数参数

216. template <typename T,int val>

217.  T add(const T& x)

218. {

219. return x + val;

220. }

221. int main()

222. {

223.   int ret = add<int, 3>(1);

224. cout << ret << endl;

225. getchar();

226. return 0;

227. }