模板参数

  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. Seqlist &operator=(const Seqlist&s)
  43. {
  44. if (this != &s)
  45. {
  46. delete[]_data;
  47. _data = new T[s._capacity];
  48. _size = s._size;
  49. _capacity = s._capacity;
  50. memcpy(_data, s._data, _capacity*sizeof(T));
  51. }
  52. return *this;
  53. }
  54. void PushBack(const T&d)
  55. {
  56. Checkcapacity();
  57. *(_data + _size) = d;
  58. _size++;
  59. }
  60. void  PopBack()
  61. {
  62. _size--;
  63. }
  64. void PushFront(const T&d)
  65. {
  66. Checkcapacity();
  67. int i = 0;
  68. for (i = _size; i > 0; i--)
  69. {
  70. *(_data + i) = *(_data + i - 1);
  71. }
  72. *_data = d;
  73. _size++;
  74. }
  75. void PopFront()
  76. {
  77. int i = 0;
  78. for (i = 0; i < _size - 1; i++)
  79. *(_data + i) = *(_data + i + 1);
  80. _size--;
  81. }
  82. void Insert(int pos, const T&d);
  83. void Sort()
  84. {
  85. T tmp = 0;
  86. int i = 0;
  87. int j = 0;
  88. for (i = 0; i < _size - 1; i++)
  89. for (j = i + 1; j < _size; j++)
  90. {
  91. if (*(_data + i) >*(_data + j))
  92. {
  93. tmp = *(_data + i);
  94. *(_data + i) = *(_data + j);
  95. *(_data + j) = tmp;
  96. }
  97. }
  98. }
  99. void print()
  100. {
  101. int i = 0;
  102. for (i = 0; i < _size; i++)
  103. cout << *(_data + i) << " ";
  104. }
  105. };
  106. template<typename T>
  107. void Seqlist<T>::Insert(int pos, const T&d)
  108. {
  109. Checkcapacity();
  110. int i = 0;
  111. for (i = _size; i>pos; i--)
  112. *(_data + i) = *(_data + i - 1);
  113. *(_data + pos) = d;
  114. _size++;
  115. }
  116. template <typename T,typename Container=Seqlist <T> >
  117. class Stack
  118. {
  119. private:
  120. Container con;
  121. public:
  122. void Push(const T&d)
  123. {
  124. con.PushBack(d);
  125. }
  126. void Pop()
  127. {
  128. con.PopBack();
  129. }
  130. void print()
  131. {
  132. con.print();
  133. }
  134. };
  135. int main()
  136. {
  137. Stack<int, Seqlist<int> >stack1;
  138. stack1.Push(1);
  139. stack1.Push(2);
  140. stack1.Push(3);
  141. stack1.Push(4);
  142. stack1.print();
  143. getchar();
  144. return 0;
  145. }
  146. 2.运用stack
  147. #include <iostream>
  148. #include <stack>
  149. using namespace std;
  150. int main()
  151. {
  152. stack<int>s;
  153. s.push(1);
  154. s.push(2);
  155. s.push(3);
  156. return 0;
  157. }
  158. 3.模板的模板参数
  159. template<typename T,template<class> class Container=Seqlist >
  160. class Stack
  161. {
  162. private:
  163. Container<T> con;
  164. public:
  165. void Push(const T&d)
  166. {
  167. con.PushBack(d);
  168. }
  169. void Pop()
  170. {
  171. con.PopBack();
  172. }
  173. void print()
  174. {
  175. con.print();
  176. }
  177. };
  178. int main()
  179. {
  180. Stack<int>s;
  181. s.Push(1);
  182. s.Push(2);
  183. s.Push(3);
  184. s.print();
  185. getchar();
  186. return 0;
  187. }
  188. 4.非类型的类模板参数
  189. template <typename T,int MAX_SIZE=10>
  190. class Seqlist
  191. {
  192. private:
  193. T data[MAX_SIZE];
  194. //public:
  195. // void show( int a)
  196. // {
  197. // cout << "show()" << endl;
  198. // }
  199. };
  200. //template <typename T, int MAX_SIZE = 10>
  201. //void Seqlist<T, MAX_SIZE>::show(int a)
  202. //{
  203. // cout << "show()" << endl;
  204. //}
  205. int main()
  206. {
  207. Seqlist<int, 10>s1;
  208. Seqlist <int, 20>s2;
  209. getchar();
  210. return 0;
  211. }
  212. 5.非类型的模板函数参数
  213. template <typename T,int val>
  214. T add(const T& x)
  215. {
  216. return x + val;
  217. }
  218. int main()
  219. {
  220. int ret = add<int, 3>(1);
  221. cout << ret << endl;
  222. getchar();
  223. return 0;
  224. }
时间： 2024-10-06 08:07:17

模板参数的相关文章

读书笔记 effective c++ Item 44 将与模板参数无关的代码抽离出来

1. 使用模板可能导致代码膨胀 使用模板是节省时间和避免代码重用的很好的方法.你不需要手动输入20个相同的类名,每个类有15个成员函数,相反,你只需要输入一个类模板,然后让编译器来为你实例化20个特定的类和300个你需要的函数.(只有在被使用的情况下类模版的成员函数才会被隐式的实例化,所以只有在300个函数被实际用到的情况下才会生成300个成员函数.)函数模板同样吸引人.你不用手动实现许多函数,你只需要实现一个函数模板,然后让编译器来做余下的事情. 然而在有些时候,如果你不小心,使用模板会导致代

c++ 模板参数做容器参数，迭代器报错 vector&lt;T&gt;::const_iterator

错误如下: template<class T>void temp(std::vector<T>& container){        std::vector<T>::const_iterator p; //error: expected ‘;’ before ‘p’        for(p = container.begin(); p != container.end(); ++p)        {                //...       

模板系列(一) 模板的模板参数

前面我们写过类似的Stack: template <typename T, typename Alloc = std::vector<T> > class Stack { public: void push(const T &); void pop(); T top() const; bool empty() const; private: Alloc _cont; }; 那么我们使用的时候需要这样: Stack<string, list<string>

STL的map容器将第3个模板参数设为less_equal或greater_equal会怎样？

最近都在学Linux系统编程,用C就足矣,有段时间没碰C++了,于是实现些算法练手. 实现多项式乘法的时候发现有几项没有合并同类项,最终调试到这一步时发现了问题. res是map类型,用find查找key为1991的key-value时,结果得到的却是<12,1>的key-value. 于是转去看那段代码,发现了问题.因为map默认是升序排列,我最后需要打印的多项式是按照幂次数(即这里res的key)降序排列,所以我需要设置map的第3个模板参数,但是由于代码补全我没确认就选择了. map&l

模板参数tag的用法

//通过结构体/类的类型来作为模板参数的tag, //用来区分tag之间的区别. //made by davidsu33 //例如对于某个全局的静态变量,你如果希望有 //很多份,但是其实现又是一样的,你可以考虑 //以模板的形式,通过类tag来区分 //而且还可以根据实际需要来特化模板 #include "stdafx.h" #include <iostream> #include <cassert> using namespace std; template

模板系列（一）模板的模板参数

在之前,我们写过类似的stack template <typename T, typename Alloc = std::vector<T> > class Stack { public: void push(const T &); void pop(); T top() const; bool empty() const; private: Alloc cont_; }; 那么我们使用的时候,需要这样写 Stack<string, list<string>

C++11 图说VS2013下的引用叠加规则和模板参数类型推导规则

背景:    最近在学习C++STL,出于偶然,在C++Reference上看到了vector下的emplace_back函数,不想由此引发了一系列的“探索”,于是就有了现在这篇博文. 前言:      右值引用无疑是C++11新特性中一颗耀眼的明珠,在此基础上实现了移动语义和完美转发,三者构成了令很多C++开发者拍案叫绝的“铁三角”(当然不是所有C++开发者).而在这个“铁三角”中,有一个无法回避的关键细节,那就是引用叠加规则和模板参数类型推导规则.其实,关于这两个规则,可查到的资料不少,但都

模板的模板参数使用示例

注意:函数模板不支持模板的模板参数. Stack7.h中定义的Stack: #ifndef STACK7_H #define STACK7_H #include <deque> #include <stdexcept> #include <memory> template <typename T, template <typename ELEM, typename = std::allocator<ELEM> > class CONT =

模板与继承之艺术——命名模板参数

一.命名模板参数 许多模板技术拖着一长串的类型参数,不过很多参数都设有合理的缺省值. template<typename Policy1 = DefaultPolicy1, typename Policy2 = DefaultPolicy2, typename Policy3 = DefaultPolicy3, typename Policy4 = DefaultPolicy4> class BreadSlicer{}; 但是如果我们需要指定某个非缺省实参,还必须明确的指定在它之前的所有实参,

模板参数推导

模板参数推导(template argument deduction),是在调用C++的模板函数时,由编译器根据使用上下文来推断所调用的模板函数的模板参数.这一概念也适用于类的模板成员函数. 类模板也存在模板参数推导的情形.例如: template <class T> struct eval; template <template <class, class...> class TT, class T1, class... Rest> struct eval<TT