C++模版全掌握（实例）

下面列出了模版的常用情况：



//
1. 模板类静态成员



template
<
typename T
>

struct
testClass


{


static

int
_data;

}

;

template
<>

int
testClass
<
char
>
::_data
=

1
;

template
<>

int
testClass
<
long
>
::_data
=

2
;


int
main(
void
)
{

cout
<<
boolalpha
<<
(
1
==
testClass
<
char
>
::_data)
<<
endl;

cout
<<
boolalpha
<<
(
2
==
testClass
<
long
>
::_data)
<<
endl;

}






//
2. 模板类偏特化



template
<
class
I,
class
O
>

struct
testClass


{

testClass()
{ cout
<<

"
I, O
"

<<
endl; }



}

;

template
<
class
T
>

struct
testClass
<
T
*
, T
*>



{

testClass()
{ cout
<<

"
T*, T*
"

<<
endl; }



}

;

template
<
class
T
>

struct
testClass
<
const
T
*
, T
*>



{

testClass()
{ cout
<<

"
const T*, T*
"

<<
endl; }



}

;


int
main(
void
)


{

testClass
<
int
,
char
>
obj1;

testClass
<
int
*
,
int
*>
obj2;

testClass
<
const

int
*
,
int
*>
obj3;

}






//
3.类模版+函数模版


template
<
class
T
>

struct
testClass


{


void
swap( testClass
<
T
>&
)
{ cout
<<

"
swap()
"

<<
endl; }



}

;

template
<
class
T
>
inline
void
swap( testClass
<
T
>&
x, testClass
<
T
>&
y )


{

x.swap( y );

}




int
main(
void
)


{

testClass
<
int
>
obj1;

testClass
<
int
>
obj2;

swap( obj1, obj2 );

}








//
4. 类成员函数模板



struct
testClass


{

template
<
class
T
>

void
mfun(
const
T
&
t )


{

cout
<<
t
<<
endl;

}



template
<
class
T
>

operator
T()


{


return
T();

}



}

;


int
main(
void
)


{

testClass obj;

obj.mfun(
1
);


int
i
=
obj;

cout
<<
i
<<
endl;

}






//
5. 缺省模板参数推导



template
<
class
T
>

struct
test


{

T a;

}

;

template
<
class
I,
class
O
=
test
<
I
>

>

struct
testClass


{

I b;

O c;

}

;




void
main()


{

}








//
6. 非类型模板参数



template
<
class
T,
int
n
>

struct
testClass
{

T _t;

testClass() : _t(n)
{

}



}

;


int
main(
void
)
{

testClass
<
int
,
1
>
obj1;

testClass
<
int
,
2
>
obj2;

}








//
7. 空模板参数



template
<
class
T
>

struct
testClass;

template
<
class
T
>

bool

operator
==
(
const
testClass
<
T
>&
,
const
testClass
<
T
>&
)


{


return

false
;





















特别注意：类，全局函数，类的成员函数都可以特化，但是只有类可以半特化，全局函数和类的成员函数不可以半特化。

//
-------------------------------------------


//
1 类的特化和类成员函数的特化



template
<
typename T
>



class
Widget1


{


public
:


void
Fun1()


{


//
generic implementation



}





}

;



template
<>



class
Widget1
<
int
>



{


public
:


void
Fun1()


{

}



}

;

template
<>



void
Widget1
<
char
>
::Fun1()


{


//
specialization



}






void
main()


{



Widget1
<
char
>
w;

w.Fun1();

Widget1
<
int
>
w2;

w2.Fun1();



}




//
-------------------------------------------


//
2 全局函数的特化和重载



template
<
typename T1, typename T2
>


T1 Fun2(T2)


{

}






//
下面2个应该是属于重载



template
<
typename T2
>



char
Fun2(T2)


{


char
c;


return
c;

}





template
<
typename T1
>


T1 Fun2(
char
)


{

}






//
全局函数的特化



template
<>



char
Fun2
<
char
,
int
>
(
int
)


{


char
c;


return
c;

}




int
main()


{

}




//
-------------------------------------------


//
3 全局函数不能半特化，以下编译失败



template
<
typename T1,typename T2
>

//
原型1



void
Test(T1,T2)


{

}





template
<
typename T1
>



void
Test
<
T1,T1
>
(T1,T1)


{

}





template
<
typename T1, typename T2
>

//
原型2



T1 Fun2(T2)


{

}




//


template
<
typename T2
>



int
Fun2
<
int
,T2
>
(T2)


{

}



template
<
typename T1
>


T1 Fun2
<
T1,
int
>
(
int
)


{

}



template
<
typename T
>


T Fun2
<
T,T
>
(T)


{