你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

C++——类模板的深入学习

[复制链接]
gaosmile 发布时间:2020-8-26 22:22
一、类模板的深入学习:
1、类模板可以定义任意多个不同的类型参数(这一点和模板函数一样)
template < typename T1, typenaem T2 >
& F9 `  U" ]7 Y! I+ ^$ d. ~! Z6 Zclass Test
1 X/ ?3 \7 z* G0 y{! u- e* I! Z: M1 s. w% U# \
public:
" y* \, A9 _+ t1 h    void add(T1 a, T2 b);4 R# L" c$ L  q2 S4 S( z) y, L+ O9 s
}' {  _1 `( W# @/ {% V8 C; K

/ Q8 t# o# Z; _- L4 b//定义类对象时
/ x$ J( h8 G. o7 {Test<int,float> t;& ]. f, V3 y  _. U* u4 T
2、类模板可以被特化
  • 指定类模板的特定实现
  • 部分类参数必须显示指定
  • 根据类型参数分开实现类模板

    , z8 C  B, J- j" n3 @! X4 h
特化前:
template < typename T1, typename T2 >1 x# _: F$ R' c% X
class Test8 ?4 I0 g5 s- @2 i, }
{4 O& m5 r. R3 s' m: @# C
   
7 j; i/ ?0 h1 d. }. a2 A};0 v- |9 X) I) K+ S- }
特化后:
template < typename T >" M# W$ W( \/ M8 O' v, w
class Test < T , T >4 m( t+ H  h6 O: Z. d, w! ?8 ^
{# p9 O' O* D' X7 a; C! `% u
  q) w% l; k" n0 ]
};3 ?) _$ v. N+ B% c1 C
3、类模板的特化类型:
  • 部分特化:用特定的规则约束类型参数
  • 完全特化:完全显示指定类型参数

    & s4 t  k$ s+ k) B6 o; o* B% o
完全特化前:
template <typename T1, typename T2 >
! o( V  U! U  H+ E1 j/ R( d- {class Test. m: u. O8 N8 a. k0 k
{5 H) R+ l" W7 F+ R: G" }+ I3 P
7 r: n4 r& _, w5 i4 W" W
};! u6 ?, N: k5 v
完全特化后:
template < >$ V8 w- p: D4 q" k
class Test < int, int>  T% c5 z" `4 _' o+ M  G
{3 |! C. C, R6 q7 r  ]
4 O. G! |3 u; R( l
, E" ?1 R; P" f; B, m6 F  q* [
};
% x+ ]+ D/ q+ C0 k( Q
代码实践:
#include <iostream>  W0 c& V! H( o  S! v0 e5 ~; h
#include <string>9 t( P% T- W- T1 x1 e' H$ |4 q

- ~3 R8 v" P  b/ M! {% Z" ausing namespace std;
. {1 ]7 }1 N3 C8 N4 C" m. h; o% B' T$ \/ i. k- I1 e5 b5 Y
template < typename T1, typename T2 >: I2 h8 p. R+ z/ r- q: g# y. F
class Test. b! E: ]! I- E; s9 ?; J2 T7 m: e
{# ?1 X4 b9 R/ `. b! l- @
public:
0 r  O3 |0 y2 F, l   void add(T1 a, T2 b)0 w3 q/ K3 u2 z1 D
   {
8 v' ]" `9 ^. f' y4 A3 g- L  J' a       cout<<"void add(T1 a, T2 b)"<<endl;
! l. D& v, S3 e! k  R2 w       cout<<a+b<<endl;$ F3 N( z# P& k( Z0 V
   }
& |5 }4 b8 _/ G};" L0 o2 {" ^7 K' i# |  _- H0 f
2 {; Z% F9 m, j. N. \* ], a# t4 `
/* 关于上述第一个类模板的特殊实现,关于指针的特化实现 */
/ Y' A- w3 ?% x% H; z0 V0 a* Vtemplate < typename T1 , typename T2 >/ y0 ]9 v( M+ D* K  f7 y1 _
class Test < T1*, T2* >
9 w, W! A: q" D7 R" F{
# }: h9 [+ s9 l$ opublic:
9 r# M  {) H5 r    void add(T1* a, T2* b)& f9 z; I% u% I5 ~% \
    {7 J" q* @" c) N  @: Q
       cout<<"void add(T1* a, T2* b)"<<endl;$ R# I" z" ]/ b) j0 A! i& u3 H
       cout<<*a+*b<<endl;- k& x2 w% W6 V5 C
    }/ `) a. v  I, j
: j2 d; S: |( V8 m  r+ E, }, D2 v$ V
};6 a! R: N' X/ D
7 ?* x! B3 o3 a4 X5 T
template < typename T >//特化
7 p3 ~9 m7 u9 Bclass Test  <T ,T  >
2 N3 U9 l% C2 l: {+ ]: z; }# ^{/ z$ `" a' F# u* k0 i- T
public:
8 c- p- u1 |' }$ _- O6 W   void add(T a, T b)
4 K6 Z2 R7 O& T8 c3 F* \6 J6 e# p8 z   {
, W" S& I! l4 x8 g         cout<<"void add(T a, T b)"<<endl;
" Z0 V# A# j+ O. \; G; r8 q         cout<<a+b<<endl;9 j, R9 v/ r4 z4 C9 q' ?
   }% ^5 A7 f* E( U- Z
   void print()' Q* y- M3 D, ^6 O$ j, c3 ]7 ~* l7 N
   {4 F" d5 Y1 O! ]% ^& d7 X8 G
# T; \: M- n4 \2 A  e3 i- K+ E" ^4 W
     cout<<"class Test  < T , T >"<<endl;% r+ t5 i2 H6 q$ L9 Q& N2 @
   }2 H+ k' h2 C- E4 b& m8 e
};, H& v# p  m$ S) g3 u

! }1 ?. r5 r/ atemplate < >//完全特化, b1 @  Z. s7 m! q
class Test < void * , void * >
( C# O5 _0 u: k2 ?: B% J/ k{
$ E( N( K- h* B8 h. ^/ Dpublic:
( \$ ~# {+ C7 b+ X   void add(void* a, void* b)+ ^6 m8 \, F& O2 j  S( M; P
   {5 b# e2 p0 y6 T
      cout<<"void add(void* a, void* b)"<<endl;7 F; h& }0 R/ P3 M2 \2 A) X
      cout<<"error to add void* parm"<<endl;/ d1 v; [9 X' p+ L  x; u
    }, G0 a1 T/ _* M
};  g3 _- k8 C- a* k5 ^% N/ w6 r* O

' q3 b) n# d/ q. O8 `, Tint main()
! Z  E! M' l; o2 T6 o! T/ h) I" [{
& x5 n# _1 X8 @9 @1 J. N    Test<int, float> t1;6 K) N% G; P  o: `; r  I
    Test<long, long> t2;8 X' Q3 W7 Q3 E7 E% O5 j6 R
    Test<void*, void*> t3;. @4 P$ D/ j! W9 ^- J

8 O6 |: i3 ?! S    t1.add(1,2.5);' m9 f0 p$ Q9 y4 W: \# t4 q! _
    t2.add(5,5);, q# @' R( U# Y7 P
    t2.print();! u2 f! I& s" s! \! O
( W9 ^1 ^& N, m; x0 Q6 F
    t3.add(NULL,NULL);8 J) V/ y5 p! C

! w* |, x- w% X    Test< int* , double* > t4;
5 B% d4 p. T5 `7 ]6 J  F/ c! C. d    int a =1;
$ ^* ^4 V+ e0 }% V    double b = 0.1;
3 k8 s* T5 p$ x& V7 W3 ]% f$ N( L
    t4.add(&a,&b);
! ]7 f9 l% E* k2 F, p   return 0;
7 R) L, k% P4 C# h  h: \& h}
# Z1 U0 W$ w( ^3 H6 i' D2 @0 n& w2 F, t, }8 B1 o) L
输出结果:
root@txp-virtual-machine:/home/txp# ./a.out0 n+ X% R; `1 m7 P. T  Z, o
void add(T1 a, T2 b)& i/ t/ I6 Z3 S; F% U* O
3.59 W2 u2 y5 @# j
void add(T a, T b)' P& M& h6 L: u+ B( w" C
10
  o1 b# @2 U, P9 n- Y+ lclass Test  < T , T >
0 m( U' }1 f$ m6 l* }3 }7 t8 B/ }void add(void* a, void* b)9 M) a: B$ ]" w. _) r
error to add void* parm
; q; S" M( }0 q- K: }6 ]void add(T1* a, T2* b)5 d& R+ q! r( @3 k
1.10 f& x; N, ]2 j# S% j
% q; i% `! E% Z4 \$ [: J  p5 z/ N
4、类模板特化注意事项:
(1)特化只是模板的分开实现
本质上是同一个类模板
(2)特化类模板的使用方式是统一的
必须显示指定每一个类型参数
5、类模板特化与重定义有区别吗?函数模板可以特化吗?
(1)重定义和特化的不同:
重定义:
--一个类模板和一个新类(或者两个类模板)
--使用的时候需要考虑如何选择的问题
特化:
--以统一的方式类使用类模板的特化类
--编译器自动优先选择特化类
(2)函数模板只支持参数完全特化
函数模板特化前:
template < typename T >
. c  z1 y9 W( K2 G- m7 U3 Q/ N' b' i6 l7 b1 \) Y" M
bool Equal(T a, T b)
9 n% K1 T6 u* [{) N/ Y) B9 Z  G$ E* r& n% `  K" I8 Q
   return a==b;6 ~8 u8 ?# t! ^) n; q0 }" T
}
6 k& M6 s" T. W" d( H7 _) s
函数模板完全特化后:
template < >) r. r+ W4 x7 Z" J- z
bool Euqal<void*>(void* a, void* b)
$ H8 h5 `5 o# i5 [+ s" S+ x- P! L{: p4 s2 c& }, W0 z. j
     return a==b;, @( f$ m- h' R% b6 k! b5 l" o
}
0 [! E9 g, ^4 M. G3 U7 c
代码实践:
#include <iostream>1 G9 [. b0 o6 E" T0 q( H
#include <string>4 W  k, u" ?9 _) v* k6 c0 J

8 l* Y) \/ i3 R; P7 h( n: vusing namespace std;. t' |( s9 {8 o5 L

1 u8 Y5 }$ _. v  j4 gtemplate
) d3 t/ }1 v9 ]* `/ l/ o4 z# P/ N< typename T1, typename T2 >; \) P( T. v  k) ?/ `
class Test) \3 d3 _/ i' j  \4 q
{
! b  s1 Y1 z" z& W3 ?6 Jpublic:
7 V, |! H4 M' ?, V/ ?    void add(T1 a, T2 b)
! S; D' l& J! n: O: a7 c7 v1 C; B    {( L5 {9 H2 \4 U/ [* `' u' C1 k& \
        cout << "void add(T1 a, T2 b)" << endl;
0 a3 v  L3 E  p7 @        cout << a + b << endl;
% ?$ {: ~, f7 Z8 {8 L    }
8 K1 f2 }' i# j. h8 @' E};! ]2 A+ J9 O# @8 n3 k4 A

1 i2 ?+ n# Q$ D7 `$ N/*
8 W0 M  X8 |! ^/ ~. _+ e, b4 R0 atemplate$ w# w% J7 m6 N
<  >
6 ?! m- J: D# q2 w& |' @class Test < void*, void* >    // 当 T1 == void* 并且 T2 == void* 时
/ j2 E" h+ o9 \7 [{" K% D/ v7 ]5 V* q
public:2 _+ e$ @& b& O3 F4 l
    void add(void* a, void* b)
5 s4 L$ W9 _7 \- \4 Z- X+ g4 K    {
8 [; i6 x- w: c+ L; Y: o        cout << "void add(void* a, void* b)" << endl;, E5 f) A( S- o, ?  Y9 d
        cout << "Error to add void* param..." << endl;6 M% [3 R- T. M3 k; R# l
    }/ @. R5 ^/ i2 N( ^2 R  d5 z
};
5 d& }! d9 c2 l) b& [, }*/
1 j- w: f8 d  T: \  k5 _* R) `5 P0 `% l4 x
class Test_Void: o; g. t7 s" T0 F. a
{  V! V5 ?) h% a$ S5 {3 u  ?1 g
public:3 j7 c7 m/ B- B: c4 }* T3 X
    void add(void* a, void* b)$ U! ]9 ]7 |2 z" |) Z5 s; K) i
    {
$ m0 H7 P0 |1 H! l: L( L- T  {        cout << "void add(void* a, void* b)" << endl;
5 q. A& w0 j2 s% A        cout << "Error to add void* param..." << endl;
: O* f3 N& w1 `/ X! A( g    }# j( K* W6 z9 G4 X' N
};* [+ O" U  P  J( c* _
' |- u) v( W3 w4 L* \
template! l# j7 P! F( k( ?# y/ i# \7 n/ y# R+ \
< typename T >
6 O4 k2 g5 P) W" Q, }6 Kbool Equal(T a, T b)
. Z+ \. e! u" p( Z! }9 ~1 C{
6 u( |6 k" D+ v6 i    cout << "bool Equal(T a, T b)" << endl;' K. i( t' _0 n
    6 O2 E6 `6 @% j2 X! T3 `+ p
    return a == b;4 d4 e2 d% Q6 R
}
3 X  v* }) r: _2 W# W; u
$ Z. w8 q8 s; b) h' F6 ~template
) f# v& W' t, Q( E< >
1 O: ^  \; j4 o$ Sbool Equal<double>(double a, double b)
/ Z. W% r9 n/ h+ k& \: N3 {{
- P% `2 F% k1 c    const double delta = 0.00000000000001;
% I5 V8 r8 j0 x! Z9 u! d1 ?  y    double r = a - b;' c5 @" F( X' e0 P9 b& ^1 C
   
3 P; M' b  x; W& u0 D, M    cout << "bool Equal<double>(double a, double b)" << endl;/ |$ Z$ S/ C; ~( J1 F# L  t/ b
   
1 s4 H, L' U" W$ N1 o    return (-delta < r) && (r < delta);
5 @* m1 [6 s$ t8 d; F/ }}
) e! {7 n( G1 a* \* a% i% O) l) v2 r( C6 T
bool Equal(double a, double b)
- W- @0 V# p0 v* J. u{. J  @' a/ e. _" j1 m0 C' x1 y
    const double delta = 0.00000000000001;
. A1 b7 g1 X! |: d/ ~. }    double r = a - b;8 E' H" ^& k: o& n' X5 {
   
7 R- f  S& E! o4 m    cout << "bool Equal(double a, double b)" << endl;% \& A6 r: Z# E* Z, T3 v
      v/ W, l9 Q$ I1 L9 j
    return (-delta < r) && (r < delta);
: C5 U  I2 D3 P" a( m. G}+ {) c, @! u; Y! c
4 R2 s/ V1 j- a7 a; R  w' @
int main()% g& Q+ {: c2 b/ l' r
{  ! W3 ?0 i0 x; \  V8 c9 |
    cout << Equal( 1, 1 ) << endl;
1 u+ k) J! z/ d0 k    cout << Equal<>( 0.001, 0.001 ) << endl;" V3 s( X4 f: e/ [/ c6 V/ I
   
) M/ t" _) ~$ k9 m0 j) Q7 i    return 0;- g, D, E; i0 _* `
}% R* ~! K6 B: G0 ^

; U8 q2 U( J2 h8 }& g: V6 Q# w' p( w2 J
输出结果:
root@txp-virtual-machine:/home/txp# ./a.out) Y4 S5 J- o* h# \- B7 `" d
bool Equal(T a, T b)
. }; g- [: j) R, S9 x3 f1
- U+ d; n: U, Cbool Equal<double>(double a, double b)
7 N& N8 n4 H) r/ @/ `3 z1! F3 o3 W% ~4 K) s* D6 y4 G2 c

) z  k7 \! }0 W  r3 Z  [( `, Q
注解:当需要重载函数模板时,优先考虑使用模板特化;当模板特化无法满足需求,再使用函数重载
二、总结:
  • 类模板可以定义任意多个不同的类型参数
  • 类模板可以被部分特化和完全特化
  • 特化的本质是模板的分开实现
  • 函数模板只支持完全特化
  • 工程中使用模板特化代替类(函数)重定义

    ! X+ k/ E5 u: |4 l4 o4 l. t- F9 }) }
好了,今天的分享就到这里,如果文章中有错误或者不理解的地方,可以交流互动,一起进步。
0 Z0 Q$ D3 ]/ ?) T0 B6 \( S" ]; Q1 w
赞 收藏 评论0 发布时间:2020-8-26 22:22

举报

0个回答
关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版