模板的显示实例化和具体化有什么区别啊，用处有什么不同？

隐式实例化：后面有程序用了，编译器才会根据模板生成一个实例函数，

显式实例化：是无论是否有程序用，编译器都会生成一个实例函数，

显示具体化：因为对于某些特殊类型，可能不适合模板实现，需要重新定义实现，此时就是使用显示具体化的场景

http://wwwcnblogscom/li-peng/p/3479994html

你定义List是个模板类，T必须用具体的类型来实例化，比如T实例化成int List list = List::Iterator begin = listbegin() 当然你也可以自定义一个类型来实例化 class MyType { } List list = List::Iterator begin = listbegin();

template<class T1,class T2> //你要多少个类型就class多少个

然后就是通用函数定义

格式是通用的，要改的只是根据情况的类型数目，和函数定义体

1三种派生方式：private public protected

private：只允许在派生类的成员函数中访问基类原有的非私有成员

public:基类中的所有公有成员和保护成员在派生类中认为公有成员和保护 成员，可以通过派生类的成员函数访问基类中所有非私有成员。还可通过派生类的对象直接访问基类中的公有成员。

protected:基类中的所有公有成员和保护成员都成了保护成员，只允许派生类的成员函数及派生类的派生类中的成员函数访问基类的非私有成员，不能通过派生类的对象直接访问基类的任何成员。

2派生类不能访问基类的私有成员。无论那种派生方式都继承了基类的所有成员，当然也包括私有成员，可以通过调用公有成员函数来访问和设置私有成员。

3保护成员的特性：能被该类和继承类的成员函数访问。

（基类中的保护成员被公有私有方式继承后的特性看第一题）

4派生类的构造函数执行之前必先调用基类的构造函数，建立基类的一个对象，当对象生命周期完结之时，先调用派生类的析构函数释放其资源，而后调用基类的析构函数。

5基类中的构造函数和析构函数都不能被继承。

派生类的构造函数：派生类中的新的或者改造来的成员则需要自己的构造函数，从基类中继承来的则调用基类的构造函数。其中分隐式调用和显式调用。析构函数需派生类中重新构造。

6多重继承：一个派生类由多个基类派生而来叫做多重继承。多重继承时，首先调用所有基类的构造函数，多个基类的构造函数的调用顺序按照定义派生类时各基类的排序确定，而后调用派生类的构造函数，析构函数为此逆序。

1调用函数模板时产生一个实例——模板函数；类模板声明时所给出的已经确定了数据类型的类成为模板类，也就是说模板类是类模板的实例。

2先调用模板函数，将具体的参数数据类型替换生成一个具体的函数使用。

类模板，是对一批仅仅成员数据类型不同的类的抽象，程序员只要为这一批类所组成的整个类家族创建一个类模板，给出一套程序代码，就可以用来生成多种具体的类，(这类可以看作是类模板的实例)，从而大大提高编程的效率。

定义类模板的一般形式是：

template class 类名{类声明体}；例如，template

class Smemory{…public:void mput(T x);…}表示定义一个名为Smemory的类模板，其中带类型参数T。

在类模板的外部定义类成员函数的一般形式是：

template

函数返回值类型 类名：：成员函数名(形参表){函数体}例如：template

void Smemory::mput(T x){…}表示定义一个类模板Smemory的成员函数，函数名为mput，形参x的类型是T，函数无返回值。

类模板是一个类家族的抽象，它只是对类的描述，编译程序不为类模板(包括成员函数定义)创建程序代码，但是通过对类模板的实例化可以生成一个具体的类以及该具体类的对象。

与函数模板不同的是：函数模板的实例化是由编译程序在处理函数调用时自动完成的，而类模板的实例化必须由程序员在程序中显式地指定，

其实例化的一般形式是：

类名 对象名

1>显式具体化

显式具体化也是基于函数模板的，只不过在函数模板的基础上，添加一个专门针对特定类型的、实现方式不同的具体化函数。

[cpp] view plain copy

template<>void swap<job>(job &a, job &b)  

{  

int salary;  

salary = asalary;  

asalary = bsalary;  

bsalary = salary;  

}  

如上所示，该具体化函数的实现与模板并不一致，编译器解析函数调用时会选择最匹配的函数定义。

2>定义同名常规函数

[cpp] view plain copy

void swap(job &a, job &b)  

{  

int salary;  

salary = asalary;  

asalary = bsalary;  

bsalary = salary;  

}  

由于编译器在重载解析时，会选择最匹配函数定义，所以在调用swap(jobA, jobB)时，编译器会选择void swap(job &a, job &b)函数定义，而屏蔽了模板函数。

同时，模板函数也可以重载，其 *** 作与常规函数一致。

[cpp] view plain copy

template <class T> void swap(T &a, T &b);  

template <class T> void swap(T &a, T &b, T &c);  

template <typename T> void swap(T &a, T &b)  

{  

T temp;  

temp = a;  

a = b;  

b = temp;  

}  

template <typename T> void swap(T &a, T &b, T &c)  

{  

T temp;  

temp = a;  

a = b;  

b = c;  

c = temp;  

}  

上面主要说的是函数模板的具体化，下面说下模板实例化。

函数模板：

[cpp] view plain copy

#define MAXNAME 128  

struct job  

{  

char name[MAXNAME]:  

int salary;  

};  

template<class T>  

void swap(T &a, T &b )  

{  

T temp;  

temp = a;  

a = b;  

b = temp;  

};  

template void swap<int>(int &a, int & b);  //显式实例化，只需声明  

template<> void swap<job>(job &a, job &b)   //显式具体化（上面已经讲过，注意与实例化区分开，必须有定义）  

{  

int salary:  

salary = asalary:  

asalary = bsalary;  

bsalary = salary;  

};//explicite specialization  

类模板：

[cpp] view plain copy

template <class T>  

class Arrary  

{  

private:  

T ar;  

int l;  

};//template class declaration  

template class Array<int>;   //explicit instantiation 显式实例化  

template<> class Array<job>  

{  

private:  

job ar;  

int l;  

};//expicit specialization   显式具体化，类定义体可以不同于类模板Array  

相应的，隐式实例化指的是：在使用模板之前，编译器不生成模板的声明和定义实例。只有当使用模板时，编译器才根据模板定义生成相应类型的实例。如：

int i=0, j=1;

swap(i, j);  //编译器根据参数i，j的类型隐式地生成swap<int>(int &a, int &b)的函数定义。

Array<int> arVal;//编译器根据类型参数隐式地生成Array<int>类声明和类函数定义。

显式实例化：

当显式实例化模板时，在使用模板之前，编译器根据显式实例化指定的类型生成模板实例。如前面显示实例化（explicit instantiation）模板函数和模板类。其格式为：

template typename function<typename>(argulist);

template class classname<typename>;

显式实例化只需声明，不需要重新定义。编译器根据模板实现实例声明和实例定义。

显示具体化：

对于某些特殊类型，可能不适合模板实现，需要重新定义实现，此时可以使用显示具体化（explicite specialization）。显示实例化需重新定义。格式为：

template<> typename function<typename>(argu_list){};

template<> class classname<typename>{};

综上：

template<> void swap<job>(job &a, job &b) {……};是函数模板的显式具体化，意思是job类型不适用于函数模板swap的定义，因此通过这个显式具体化重新定义；也可简写作template<> void swap(job &a, job &b);

template void swap<job>(job &a, job &b);是函数模板的一个显式实例化，只需声明，编译器遇到这种显式实例化，会根据原模板的定义及该声明直接生成一个实例函数，该函数仅接受job型。否则编译器遇到模板的使用时才会隐式的生成相应的实例函数。