c++模板

参考链接： C++模板

1.什么是模板 

假设现在我们完成这样的函数，给定两个数x和y求式子x^2 + y^2 +　x * y的值 .考虑到x和y可能是 int ， float 或者double类型，那么我们就要完成三个函数： 

int fun(int x,int y); 

float fun(float x,float y); 

double fun(double x,double y); 

并且每个fun函数内部所要完成的操作也是极其的相似。如下： 

 View Code 

可以看出，上面的三个函数体除了类型不一样之外，其他的完全一样，那么如果能够只写一个函数就能完成上面的三个函数的功能该多好呢？如果从这三个函数提炼出一个通用函数，而它又适用于这三种不同类型的数据，这样会使代码的重用率大大提高。实际上C++中的模板正好就是来解决这个问题的。模板可以实现类型的参数化(把类型定义为参数)，从而实现了真正的代码可重用性。C++中的模板可分为函数模板和类模板，而把函数模板的具体化称为模板函数，把类模板的具体化成为模板类。下面让我们分别看看什么是函数模板和类模板吧~~~ 

2.模板函数 

实际上我们利用函数模板，只需要一个函数就可能完成上面的三个函数了，千言万语不如看代码：  

   1 #include <iostream>

 2 

 3 using namespace std;

 4 

 5 template <typename T>

 6 T fun(T x,T y)

 7 {

 8     T tmp = x *x + y * y + x * y;

 9     return tmp;

10 }

11 int main()

12 {

13     int x1 = 1,y1 = 4;

14     float x2 = 1.1 , y2 = 2.2;

15     double x3 = 2.0 , y3 = 3.1;

16     cout<<fun(x1,y1)<<endl;

17     cout<<fun(x2,y2)<<endl;

18     cout<<fun(x3,y3)<<endl;

19     return 0;

20 } 

运行结果： 

如此利用模板，我们很轻而易举的达到了我们的目的，而这也大大的提高了代码的可重用性，这也让我们想起了STL中的那些算法了吧，这些算法使用多种的数据类型。实际上STL即使模板的重要应用了。 

现在我们想，如果上面的代码这样调用fun(x1,y2)会怎么样呢？点击编译会出现这样的错误： 

可以看到编译编译出现问题的是fun(x1,y2)，说的意思就是没有对应的函数，要么x1和y2都是int型，要么x1和y2都是float型。那么我为什么要说一下这样一种情况呢？主要是为了引出模板也可以同时使用两个： 

   1 #include <iostream>

 2 

 3 using namespace std;

 4 

 5 

 6 template <typename T1 , typename T2>

 7 T2 fun(T1 x,T2 y)

 8 {

 9     T2 tmp = x *x + y * y + x * y;

10     return tmp;

11 }

12 int main()

13 {

14     int x1 = 1,y1 = 4;

15     float x2 = 1.1 , y2 = 2.2;

16     double x3 = 2.0 , y3 = 3.1;

17     cout<<fun(x1,y1)<<endl;

18     cout<<fun(x2,y2)<<endl;

19     cout<<fun(x3,y3)<<endl;

20     cout<<fun(x1,y2)<<endl;

21     return 0;

22 } 

运行结果： 

当使用两个模板时，为什么fun(x1,y1)也能正确运行呢？因为当进行这个调用时，T1 = int ，T2 = int。所以这种调用也是没有问题的。 

提到函数想到重载是很自然的吧，那么模板函数能不能重载呢？显然是能的了，还是看代码： 

 View Code 

运行结果： 

从结果已经能看出来模版函数的重载是没有任何问题的了。那么模板函数和非模板函数之间是否能够重载呢？？ 

 View Code 

运行结果： 

看以看出模版函数和非模板函数也是可能重载的，那么重载函数的调用顺序是怎么样的呢？实际上是先查找非模板函数，要有严格匹配的非模板函数，就调用非模板函数，找不到适合的非模板函数在和模板函数进行匹配。 

到这里，关于模板就说这些吧~~~~ 

3.模板类 

要是理解了模版函数，模板类就相当的简单了，只不过模版函数是对函数中的类型使用模板，而模板类是对类中的类型使用模板，这我就不多说了，下面的代码是我以前利用模板写的单链表，这个是模板的典型应用：（测试过） 

    1 #include <stdio.h>

  2 #include <iostream.h>

  3 

  4 template <class T>

  5 struct SLNode

  6 {

  7     T data;

  8     SLNode<T> *next;

  9     SLNode(SLNode<T> *nextNode=NULL)

 10     {

 11         next = nextNode;

 12     }

 13     SLNode(const T &item,SLNode<T> *nextNode=NULL)

 14     {

 15         data = item;

 16         next = nextNode;

 17     }

 18 };

 19 

 20 template <class T>

 21 class SLList

 22 {

 23 private:

 24     SLNode<T> *head;

 25     SLNode<T> *tail;

 26     SLNode<T> *currptr;

 27     int size;

 28 public:

 29     SLList();

 30     SLList(const T &item);

 31     ~SLList();

 32     bool IsEmpty()const;

 33     int Length()const;

 34     bool Find(int k,T &item)const;

 35     int Search(const T &item)const;

 36     void InsertFromHead(const T &item);

 37     void InsertFromTail(const T &item);

 38     bool DeleteFromHead(T &item);

 39     bool DeleteFromTail(T &item);

 40     void Insert(int k,const T &item);

 41     void Delete(int k,T &item);

 42     void ShowListMember();

 43 };

 44 //构造函数

 45 template <class T>

 46 SLList<T>::SLList()

 47 {

 48     head = tail = currptr = new SLNode<T>();

 49     size = 0;

 50 }

 51 //构造函数

 52 template <class T>

 53 SLList<T>::SLList(const T &item)

 54 {

 55     tail = currptr = new SLNode<T>(item);

 56     head = new SLNode<T>(currptr);

 57     size = 1;

 58 }

 59 //析构函数

 60 template <class T>

 61 SLList<T>::~SLList()

 62 {

 63      SLNode<T> *temp;

 64     while(!IsEmpty())

 65     {

 66         temp = head->next;

 67         head->next = temp->next;

 68         delete temp;

 69         

 70     }

 71 }

 72 //判断链表是否为空

 73 template <class T>

 74 bool SLList<T>::IsEmpty()const

 75 {

 76     return head->next == NULL;

 77 }

 78 //返回链表的长度

 79 template <class T>

 80 int SLList<T>::Length()const

 81 {

 82      return size;

 83 }

 84 //查找第k个节点的阈值

 85 template <class T>

 86 bool SLList<T>::Find(int k,T &item)const

 87 {

 88     if(k < 1)

 89     {

 90         cout<<"illegal position !"<<endl;

 91     }

 92     SLNode<T> *temp = head;

 93     int count = 0;

 94     while(temp != NULL && count < k)

 95     {

 96         temp = temp->next;

 97         count++;

 98     }

 99     if(temp == NULL)

100     {

101         cout<<"The list does not contain the K node !"<<endl;

102         return false;

103     }

104     item = temp->data;

105     return true;

106 }

107 //查找data阈值为item是表的第几个元素

108 template <class T>

109 int SLList<T>::Search(const T &item)const

110 {

111     SLNode<T> *temp = head->next;

112     int count = 1;

113     while(temp != NULL && temp->data != item)

114     {

115         temp = temp->next;

116         count++;

117     }

118     if(temp == NULL)

119     {

120         cout<<"The node does not exist !"<<endl;

121         return -1;

122     }

123     else

124     {

125         return count;

126     }

127 }

128 //从表头插入

129 template <class T>

130 void SLList<T>::InsertFromHead(const T &item)

131 {    

132     if(IsEmpty())

133     {

134         head->next = new SLNode<T>(item,head->next);

135         tail = head->next;

136     }

137     else

138     {

139         head->next = new SLNode<T>(item,head->next);

140     }

141     size++;

142 }

143 //从表尾插入

144 template <class T>

145 void SLList<T>::InsertFromTail(const T &item)

146 {

147     tail->next = new SLNode<T>(item,NULL);

148     tail = tail->next;

149     size++;

150 }

151 //从表头删除

152 template <class T>

153 bool SLList<T>::DeleteFromHead(T &item)

154 {

155     if(IsEmpty())

156     {

157         cout<<"This is a empty list !"<<endl;

158         return false;

159     }

160     SLNode<T> *temp = head->next;

161     head->next = temp->next;

162     size--;

163     item = temp->data;

164     if(temp == tail)

165     {

166         tail = head;

167     }

168     delete temp;

169     return true;

170 }

171 //从表尾删除

172 template <class T>

173 bool SLList<T>::DeleteFromTail(T &item)

174 {

175     if(IsEmpty())

176     {

177         cout<<"This is a empty list !"<<endl;

178         return false;

179     }

180     SLNode<T> *temp = head;

181     while(temp->next != tail)

182     {

183         temp = temp->next;

184     }

185     item = tail->data;

186     tail = temp;

187     tail->next=NULL;

188     temp = temp->next;

189     delete temp;

190     size--;

191     return true;

192 }

193 //在第k个节点后插入item值

194 template <class T>

195 void SLList<T>::Insert(int k,const T &item)

196 {

197     if(k < 0 || k > size)

198     {

199         cout<<"Insert position Illegal !"<<endl;

200         return;

201     }

202     if(k == 0)

203     {

204         InsertFromHead(item);

205         return;

206     }

207     if(k == size)

208     {

209         InsertFromTail(item);

210         return;

211     }

212     SLNode<T> *temp = head->next;

213     int count = 1;

214     while(count < k)

215     {

216         count++;

217         temp = temp->next;

218     }

219     SLNode<T> *p = temp->next;

220     temp->next = new SLNode<T>(item,p);

221     size++;

222 }

223 //删除第k个节点的值，保存在item中

224 template <class T>

225 void SLList<T>::Delete(int k,T &item)

226 {

227     if(k <= 0 || k > size)

228     {

229         cout<<"Ileegal delete position !"<<endl;

230         return;

231     }

232     if(k == 1)

233     {

234         DeleteFromHead(item);

235         return;

236     }

237     if(k == size)

238     {

239         DeleteFromTail(item);

240         return;

241     }

242     SLNode<T> *temp = head->next;

243     int count = 1;

244     while(count < k-1)

245     {

246         count++;

247         temp = temp->next;

248     }

249     SLNode<T> *p = temp->next;

250     temp->next = p->next;

251     p->next = NULL;

252     item = p->data;

253     delete p;

254     size--;

255 }

256 template <class T>

257 void SLList<T>::ShowListMember()

258 {

259     cout<<"List Member : ";

260     SLNode<T> *temp = head->next;

261     while(temp != NULL)

262     {

263         cout<<temp->data<<" ";

264         temp = temp->next;

265     }

266     cout<<endl;

267 }

268 

269 /*

270 1.引入了InsertFronHead,InsertFromTail,DeleteFromHead和DeleteFromTail用来实现

271   Insert和Delete函数，是一个比较好的方法。

272 2.SLNode(T &item,SLNode<T> *nextNode)这个构造函数设计的非常巧妙，便于其他成员

273   函数的实现。

274 3.插入，删除分为：表头，表尾，中间插入（删除）三种情况

275 */

276 

277 

278 

279 int main()

280 {

281     int item;

282     SLList<int> list(12);

283 

284     list.Insert(0,11);

285     cout<<"list number:"<<list.Length()<<endl;

286     list.ShowListMember();

287 

288     list.Insert(2,14);

289     cout<<"list number:"<<list.Length()<<endl;

290     list.ShowListMember();

291 

292     list.Insert(2,13);

293     cout<<"list number:"<<list.Length()<<endl;

294     list.ShowListMember();

295 

296     list.Delete(2,item);

297     cout<<"item = "<<item<<endl;

298     cout<<"list number:"<<list.Length()<<endl;

299     list.ShowListMember();

300 

301     list.Delete(1,item);

302     cout<<"item = "<<item<<endl;

303     cout<<"list number:"<<list.Length()<<endl;

304     list.ShowListMember();

305 

306     list.Delete(2,item);

307     cout<<"item = "<<item<<endl;

308     cout<<"list number:"<<list.Length()<<endl;

309     list.ShowListMember();

310     return 0;

311 } 

利用模板的好处是，SLList中的数据可以是任意的数据类型，这也就是泛型编程的概念了吧~~~~