1． 函数模板 及 类模板 定义实现使用

2． 函数模板重载
3． 类模板 定做 及部分定做 定义实现
4． LINUX UBANTU_G++不支援 显式实例化声名
 
----------------------------------
Time:2013-1-4

Developer: ubantu_g++

 
 
#include<iostream>
#include<string>
 
using namespace std;
 

//how to define a template function------------------------------------

template<typename T>
void print(T const & arg)
{

         cout<<"template function"<<endl\

             <<arg<<endl;
}

//how to overload a template function------------------------------------

template<typename T1,typename T2>

void print(T1 const& a, T2 const& b)

{

         cout<<"multi-args and overload function"<<endl\

             <<a<<endl\
             <<b<<endl;
}
 
 

//how to define a template class------------------------------------

template<typename T>
class obj
{
private:

         T content;

public:

         obj(T const& arg);

         void print(void);       

};
 
template<typename T>
obj<T>::obj(T const& arg)
{

         content = arg;

}
 
template<typename T>
void obj<T>::print(void)
{

         cout<<"template obj"<<endl\

             <<content<<endl;
}

//how to define a specialization class from a exist template class------------------------------------------

 
template<>
class obj<string>
{
private:

         string content;

public:

         obj(const string & str);

         void print(void);

};
 

obj<string>::obj(const string& str):content(str){}

 
void obj<string>::print(void)
{

         cout<<"specialization template"<<endl\

             <<content<<endl;
}
 

//mult_args template calss------------------------------------------

template<typename T1, typename T2>
class obj_
{
private:

         T1 cont0;

         T2 cont1;

public:

         obj_(const T1&, const T2&);

         void print(void);

};
 
template<typename T1, typename T2>

obj_<T1,T2>::obj_(const T1& a, const T2& b):cont0(a),cont1(b){}

 
template<typename T1, typename T2>
void obj_<T1,T2>::print(void)
{

         cout<<"mult_args template calss"<<endl\

             <<cont0<<endl\
             <<cont1<<endl;
}
 

//partial specialization template class------------------------------------------

template<typename T>
class obj_<T, string>
{
private:

         T cont0;

         string cont1;

public:

         obj_(const T&, const string&);

         void print(void);

};
 
template<typename T>

obj_<T, string>::obj_(const T & a, const string & b):cont0(a),cont1(b){}

 
template<typename T>
void obj_<T, string>::print(void)
{

         cout<<"partial specialization template class"<<endl\

             <<cont0<<endl\
             <<cont1<<endl;
}
 
//------------------------------------------
int main(void)
{

         int a = 100;

         double b =1.111;

         string str ("this is string");

        
        
        

        //test template function

         print(a);
         print(b);

         //test multi-types in template and overload it

         print(str,b);

         //test template class

         obj<int>object(100);
         object.print();

         //test mulit-types class

         obj_<string, int>object_m(str, a);

         object_m.print();

        //test specialization template class

         obj<string>ObjStr(str);
         ObjStr.print();

         //test partial specialization template class

         obj_<int ,string>object_(a,str);

         object_.print();
        

         //test instantial delay

         //template obj<double>;显式实例化声名 无法通过编译

 

         return 0;

}