C++中的模板

Templates

定义一个模板使用的关键字：class和typename。

在定义作为模板的时候：class和typename，作用是一样的

出处：http://www.cplusplus.com/doc/tutorial/templates/

一 函数模板

1 定义方式

template <class identifier> function_declaration;
template <typename identifier> function_declaration;

2 Example

template <class T>
T GetMax (T a, T b)
{
       T result;

       result = (a>b)? a : b;

       return (result);
}

3 使用方法

function_name <type> (parameters);

例如： 
int x,y;
GetMax <int> (x,y);

对于内部类型，通常是可以无需制定具体的类型，编译器会自动识别，

而是写成：

 

int x,y;

GetMax(x,y);     //x，y为相同的类型

 

int x;

long y;

GetMax(x,y);     //x，y为不相同的类型 报错 两种不同的内部类型

必须：

template <class T, class U>
T GetMin (T a, U b) 
{
  return (a<b?a:b);
}
 

int i,j;
long l;
i = GetMin<int,long> (j,l);           //或者i = GetMin (j,l);

二 Class Template

通常是使用模板作为类成员变量的类型

1 Example：

template <class T>
class mypair 
{
    T values [2];
  public:
    mypair (T first, T second)                //内联函数     
    {
      values[0]=first; values[1]=second;
    }
};

mypair<int> myobject (115, 36);               //这样使用
mypair<double> myfloats (3.0, 2.18);

2 成员函数为非内联函数

template <class T>
class mypair {
    T a, b;
  public:
    mypair (T first, T second)
      {a=first; b=second;}
    T getmax ();
};
 
template <class T>             //增加此声明           
T mypair<T>::getmax ()
{
  T retval;
  retval = a>b? a : b;
  return retval;
}
 
int main () {
  mypair <int> myobject (100, 75);
  cout << myobject.getmax();
  return 0;
}

模板类成员函数外部定义方法：

template <class T>
T mypair<T>::getmax ()

三 模板特化 Template Specialization

1 将模板类转化为特定类型相关的类

// class template:
template <class T>
class mycontainer 
{
    T element;
  public:
    mycontainer (T arg) {element=arg;}
    T increase () {return ++element;}
};
 
// class template specialization:
template <>                           //
class mycontainer <char>            //将其特例化为char型
{
    char element;
  public:
    mycontainer (char arg) {element=arg;}
    char uppercase ()
    {
      if ((element>='a')&&(element<='z'))
      element+='A'-'a';
      return element;
    }
};
 
int main () {
  mycontainer<int> myint (7);
  mycontainer<char> mychar ('j');
  cout << myint.increase() << endl;
  cout << mychar.uppercase() << endl;
  return 0;
}

template <class T> class mycontainer { ... }; //模板类
template <> class mycontainer <char> { ... }; //特例化为char型
template <> class mycontainer <int> { ... };  //特例化为int型

模板来与之相应的特例化的类之间，并不是什么继承关系，

所以在特例化一个模板类时，需要将其所有的包含成员进行重写，可以进行扩展。

 

2 非模板类型参数 Non-type parameters for templates

 

template <class T, int N>             //int N
class mysequence 
{
    T memblock [N];
  public:
    void setmember (int x, T value);
    T getmember (int x);
};
 
template <class T, int N>
void mysequence<T,N>::setmember (int x, T value) 
{
  memblock[x]=value;
}
 
template <class T, int N>
T mysequence<T,N>::getmember (int x)
{
  return memblock[x];
}
 
int main () {
  mysequence <int,5> myints;
  mysequence <double,5> myfloats;
  myints.setmember (0,100);
  myfloats.setmember (3,3.1416);
  cout << myints.getmember(0) << '\n';
  cout << myfloats.getmember(3) << '\n';
  return 0;
}

可以设置模板类型的缺省值：

template <class T=char, int N=10> class mysequence {..};
 
mysequence<> myseq;            //可以缺省使用 
mysequence<char,10> myseq;     //等同于上面

四 Templates and multiple-file projects

　　From the point of view of the compiler, templates are not normal functions or classes.

They are compiled on demand, meaning that the code of a template function is

not compiled until an instantiation with specific template arguments is required.

At that moment, when an instantiation is required, the compiler generates a function specifically

for those arguments from the template.

1 模板不会在代码编译的时候直接进行编译，而是在被实例化一个特定类型的模板时候，才会编译到，生成一个特定参数的函数。

When projects grow it is usual to split the code of a program in different source code files.

In these cases, the interface and implementation are generally separated.

Taking a library of functions as example, the interface generally consists of

declarations of the prototypes of all the functions that can be called.

These are generally declared in a "header file" with a .h extension,

and the implementation (the definition of these functions) is in an independent file with c++ code.
  
Because templates are compiled when required, this forces a restriction

for multi-file projects: the implementation (definition) of a template class

or function must be in the same file as its declaration.

That means that we cannot separate the interface in a separate header file,

and that we must include both interface and implementation in any file that uses the templates.

2 由于模板特殊的编译需要，模板类的定义和函数实现必须在同一个文件中进行。

Since no code is generated until a template is instantiated when required,

compilers are prepared to allow the inclusion more than once of the same

template file with both declarations and definitions in a project without generating linkage errors.

五 typename

定义一个模板使用的关键字：class和typename。

在定义作为模板的时候：class和typename，作用是一样的。

使用typename，实际上也是为模板服务的，在某些情况下我们需要明确的指出某些变量为模板。

1 在一个模板类中使用另一个模板类定义一个变量时

template<typename T>
struct first 
{
    typedef T * pointer;
};
template<typename T>
class second 
{
    first<T>::pointer p;       // syntax error （VC++中 并不报错）
};

 In a template, the name of a member of another class that depends on

its template parameter(s) (first<T>::pointer in this example, dependent

on the T parameter) is a dependent name that is not looked-up immediately.

To tell the compiler that it is meant to refer to a type and not some other sort of member,

you must add the keyword typename before it.

typename 能够在：依赖类型中，typename用来声明一个依赖于另一个模板类参数的嵌套类型。