my stl study-road<template>

模板的定义：

  template <class TYPE>

  template <typename T, int SIZE>   //typename可以替代class声明模板

多参数，带缺省值得:

  template <class TYPE,class ARG=vector<TYPE> >

  如果只传给它一个参数，缺省参数可以作为第二参数使用.

关键字typename

  typename 被作为型别之前的标识符号。

 eg:

[html] view plain copy

1. #include <iostream>  
2. #include "MyClass.h"  
3.   
4. using namespace std;  
5.   
6. class Q{  
7. public:  
8.         typedef int SubType;  
9. };  
10. int main()  
11. {  
12.     cout << "Hello world!" << endl;  
13.     MyClass<Q> x;  
14.   
15.     return 0;  
16. }  

-----------MyClass.h------------

[html] view plain copy

1. template<class T>  
2. class MyClass  
3. {  
4.         public:  
5.                 MyClass();  
6.                 ~MyClass();  
7.                 MyClass(const MyClass& other);  
8.                 void printf();  
9.         protected:  
10.         private:  
11.                 typename T::SubType * ptr;  
12. };  

说明：Subtype成为一个型别的必要条件是：

任何一个用来取代T的型别，其内部必须提供SubType的定义.

模板类的拷贝构造（缺省）和模板构造：

[html] view plain copy

1. #ifndef MYCLASS_H  
2. #define MYCLASS_H  
3.   
4. template<class T>  
5. class MyClass  
6. {  
7.         public:  
8.                 MyClass();  
9.                 ~MyClass();  
10.                 //MyClass(const MyClass& other);  
11.                 template<class X>  
12.                 MyClass(const MyClass<X>& other)  
13.                 {  
14.                         //copy ctor  
15.                         ptr=other.getvalue();  
16.                 }  
17.                 T getvalue() const  
18.                 {  
19.                         return ptr;  
20.                 }  
21. //                MyClass(const MyClass& other)  
22. //                {  
23. //                        //copy ctor  
24. //                        ptr=other;  
25. //                }  
26.   
27.                 void printf();  
28.         protected:  
29.         private:  
30.                  T ptr;  
31. };  

--------------main----------------------

[html] view plain copy

1. int main()  
2. {  
3.     cout << "Hello world!" << endl;  
4.     MyClass<int> x;  
5.     MyClass<double> y(x);  
6.   
7.     return 0;  
8. }  

如果不用 Myclass<X>,则main函数里面是报错的。即使有隐含的double到int类型的强制转化。

而加了Myclass<X>则轻松解决了这一问题。值得注意的是，这里没有用：ptr=other.ptr的原因：

ptr是类的私有成员变量，这里是在 MyClass<T>里面，只能调用T的ptr，X的ptr在T内是不可见的。所以这里用到了getvalue函数。

显示初始化：

int i1;

int i2=int();

template <class T>

void f()

{

     T x=T();

}

//调用的是缺省的构造函数.