wordpress容易被黑吗,青岛seo服务公司,移动商城积分兑换,wordpress的文章多重筛选函数模板
函数模板语法 所谓函数模板#xff0c;实际上是建立一个通用函数#xff0c;其函数类型和形参类型不具体指定#xff0c;用一个虚拟的类型来代表。这个通用函数就称为函数模板。 凡是函数体相同的函数都可以用这个模板来代替#xff0c;不必定义多个函数#xf…函数模板
函数模板语法 所谓函数模板实际上是建立一个通用函数其函数类型和形参类型不具体指定用一个虚拟的类型来代表。这个通用函数就称为函数模板。 凡是函数体相同的函数都可以用这个模板来代替不必定义多个函数只需在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型从而实现了不同函数的功能。
函数模板定义形式
由以下三部分组成 模板说明 函数定义 函数模板调用 template 类型形式参数表 类型 函数名 (形式参数表)
{//语句序列
}1.模板说明
template 类型形式参数表
类型形式参数的形式
typename T1,typename T2,typename Tn……或class T1,class T2
(typename 和 class的效果完全相等)
2.函数定义 类型 函数名 (形式参数表) { } **注意**模板说明的类属参数必须在函数定义中出现一次
函数参数表中可以使用类属类型参数也可以使用一般类型参数3.模板函数调用
maxint(a, b); //显式类型调用
max(a, b); //自动数据类型推导
4.函数模板 5.函数模板和函数重载
// demo 15-4.c
#include iostream
using namespace std;template typename T
void Swap(T a, T b){T t;t a;a b;b t;coutSwap 模板函数被调用了endl;
}/*
void Swap(char a, int b){int t;t a;a b;b t;coutSwap 普通函数被调用了endl;
}
*/void main(void){char cNum c;int iNum 65;//第一种情况模板函数和普通函数并存,参数类型和普通重载函数更匹配//调用普通函数//Swap(cNum, iNum);//第二种情况 不存在普通函数函数模板会隐式数据类型转换嘛//结论不提供隐式的数据类型转换,必须是严格的匹配//Swap(cNum, iNum);system(pause);return ;
}
函数模板和普通函数区别结论
两者允许并存
函数模板不允许自动类型转化
普通函数能够进行自动类型转换
// demo 15-5.c
#include iostreamusing namespace std;//第一版
int Max(int a, int b)
{cout调用 int Max(int a, int b)endl;return ab ? a:b;
}templatetypename T
T Max(T a, T b)
{cout调用 T Max(T a, T b)endl;return ab ? a:b;
}template typename T
T Max(T a, T b, T c){cout调用 T Max(T a, T b, T c)endl;return Max(Max(a, b), c);
}//第二版
int Max1(int a, int b)
{cout调用 int Max(int a, int b)endl;return ab ? a:b;
}templatetypename T1, typename T2
T1 Max1(T1 a, T2 b)
{cout调用 T Max1(T1 a, T2 b)endl;return ab ? a:b;
}void main(void){int a 1;int b 2;//当函数模板和普通函数都符合调用时,优先选择普通函数//coutMax(a, b)Max(a, b)endl;//如果显式的使用函数模板,则使用 类型列表//Max(a, b);char c a;//如果函数模板会产生更好的匹配使用函数模板//Max1(c, a);//Max(1.0, 2.0);Max(3.0, 4.0, 5.0);system(pause);return ;
}函数模板和普通函数在一起调用规则
1 函数模板可以像普通函数一样被重载
2 C编译器优先考虑普通函数
3 如果函数模板可以产生一个更好的匹配那么选择模板
4 可以通过空模板实参列表的语法限定编译器只通过模板匹配
函数模板调用机制
// demo 15-6.c
#include iostream
using namespace std;template typename T
T Max(T a, T b){return ab ? a:b;
}int main()
{int x 1;int y 2;Max(x, y);float a 2.0;float b 3.0;Max(a, b);return 0;
}
*反汇编观察*
// demo.c
#include iostream
using namespace std;int Max(int a, int b){return ab ? a:b;
}
int main()
{int x 1;int y 2;Max(x, y);return 0;
}// demo.S.file demo.cpp.local _ZStL8__ioinit.comm _ZStL8__ioinit,1,1.text.globl _Z3Maxii.type _Z3Maxii, function
_Z3Maxii:
.LFB1021:.cfi_startprocpushq %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq %rsp, %rbp.cfi_def_cfa_register 6movl %edi, -4(%rbp)movl %esi, -8(%rbp)movl -4(%rbp), %eaxcmpl -8(%rbp), %eaxjle .L2movl -4(%rbp), %eaxjmp .L4
.L2:movl -8(%rbp), %eax
.L4:popq %rbp.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1021:.size _Z3Maxii, .-_Z3Maxii.globl main.type main, function
main:
.LFB1022:.cfi_startprocpushq %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq %rsp, %rbp.cfi_def_cfa_register 6subq $16, %rspmovl $1, -8(%rbp)movl $2, -4(%rbp)movl -4(%rbp), %edxmovl -8(%rbp), %eaxmovl %edx, %esimovl %eax, %edicall _Z3Maxiimovl $0, %eaxleave.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1022:.size main, .-main.type _Z41__static_initialization_and_destruction_0ii, function
_Z41__static_initialization_and_destruction_0ii:
.LFB1023:.cfi_startprocpushq %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq %rsp, %rbp.cfi_def_cfa_register 6subq $16, %rspmovl %edi, -4(%rbp)movl %esi, -8(%rbp)cmpl $1, -4(%rbp)jne .L9cmpl $65535, -8(%rbp)jne .L9movl $_ZStL8__ioinit, %edicall _ZNSt8ios_base4InitC1Evmovl $__dso_handle, %edxmovl $_ZStL8__ioinit, %esimovl $_ZNSt8ios_base4InitD1Ev, %edicall __cxa_atexit
.L9:nopleave.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1023:.size _Z41__static_initialization_and_destruction_0ii, .-_Z41__static_initialization_and_destruction_0ii.type _GLOBAL__sub_I__Z3Maxii, function
_GLOBAL__sub_I__Z3Maxii:
.LFB1024:.cfi_startprocpushq %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq %rsp, %rbp.cfi_def_cfa_register 6movl $65535, %esimovl $1, %edicall _Z41__static_initialization_and_destruction_0iipopq %rbp.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1024:.size _GLOBAL__sub_I__Z3Maxii, .-_GLOBAL__sub_I__Z3Maxii.section .init_array,aw.align 8.quad _GLOBAL__sub_I__Z3Maxii.hidden __dso_handle.ident GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.5) 5.4.0 20160609.section .note.GNU-stack,,progbits
// demo_06.cpp
#include iostream
using namespace std;template typename T
T Max(T a, T b){return ab ? a:b;
}int main()
{int x 1;int y 2;Max(x, y);float a 2.0;float b 3.0;Max(a, b);return 0;
}g -S demo_06.cpp -o demo.S
// demo_06.S.file demo_06.cpp.local _ZStL8__ioinit.comm _ZStL8__ioinit,1,1.text.globl main.type main, function
main:
.LFB1022:.cfi_startprocpushq %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq %rsp, %rbp.cfi_def_cfa_register 6subq $32, %rspmovl $1, -16(%rbp)movl $2, -12(%rbp)movl -12(%rbp), %edxmovl -16(%rbp), %eaxmovl %edx, %esimovl %eax, %edicall _Z3MaxIiET_S0_S0_movss .LC0(%rip), %xmm0movss %xmm0, -8(%rbp)movss .LC1(%rip), %xmm0movss %xmm0, -4(%rbp)movss -4(%rbp), %xmm0movl -8(%rbp), %eaxmovaps %xmm0, %xmm1movl %eax, -20(%rbp)movss -20(%rbp), %xmm0call _Z3MaxIfET_S0_S0_movl $0, %eaxleave.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1022:.size main, .-main.section .text._Z3MaxIiET_S0_S0_,axG,progbits,_Z3MaxIiET_S0_S0_,comdat.weak _Z3MaxIiET_S0_S0_.type _Z3MaxIiET_S0_S0_, function
_Z3MaxIiET_S0_S0_:
.LFB1023:.cfi_startprocpushq %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq %rsp, %rbp.cfi_def_cfa_register 6movl %edi, -4(%rbp)movl %esi, -8(%rbp)movl -4(%rbp), %eaxcmpl -8(%rbp), %eaxjle .L4movl -4(%rbp), %eaxjmp .L6
.L4:movl -8(%rbp), %eax
.L6:popq %rbp.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1023:.size _Z3MaxIiET_S0_S0_, .-_Z3MaxIiET_S0_S0_.section .text._Z3MaxIfET_S0_S0_,axG,progbits,_Z3MaxIfET_S0_S0_,comdat.weak _Z3MaxIfET_S0_S0_.type _Z3MaxIfET_S0_S0_, function
_Z3MaxIfET_S0_S0_:
.LFB1024:.cfi_startprocpushq %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq %rsp, %rbp.cfi_def_cfa_register 6movss %xmm0, -4(%rbp)movss %xmm1, -8(%rbp)movss -4(%rbp), %xmm0ucomiss -8(%rbp), %xmm0jbe .L13movss -4(%rbp), %xmm0jmp .L11
.L13:movss -8(%rbp), %xmm0
.L11:popq %rbp.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1024:.size _Z3MaxIfET_S0_S0_, .-_Z3MaxIfET_S0_S0_.text.type _Z41__static_initialization_and_destruction_0ii, function
_Z41__static_initialization_and_destruction_0ii:
.LFB1025:.cfi_startprocpushq %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq %rsp, %rbp.cfi_def_cfa_register 6subq $16, %rspmovl %edi, -4(%rbp)movl %esi, -8(%rbp)cmpl $1, -4(%rbp)jne .L16cmpl $65535, -8(%rbp)jne .L16movl $_ZStL8__ioinit, %edicall _ZNSt8ios_base4InitC1Evmovl $__dso_handle, %edxmovl $_ZStL8__ioinit, %esimovl $_ZNSt8ios_base4InitD1Ev, %edicall __cxa_atexit
.L16:nopleave.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1025:.size _Z41__static_initialization_and_destruction_0ii, .-_Z41__static_initialization_and_destruction_0ii.type _GLOBAL__sub_I_main, function
_GLOBAL__sub_I_main:
.LFB1026:.cfi_startprocpushq %rbp.cfi_def_cfa_offset 16.cfi_offset 6, -16movq %rsp, %rbp.cfi_def_cfa_register 6movl $65535, %esimovl $1, %edicall _Z41__static_initialization_and_destruction_0iipopq %rbp.cfi_def_cfa 7, 8ret.cfi_endproc
.LFE1026:.size _GLOBAL__sub_I_main, .-_GLOBAL__sub_I_main.section .init_array,aw.align 8.quad _GLOBAL__sub_I_main.section .rodata.align 4
.LC0:.long 1073741824.align 4
.LC1:.long 1077936128.hidden __dso_handle.ident GCC: (Ubuntu 5.4.0-6ubuntu1~16.04.5) 5.4.0 20160609.section .note.GNU-stack,,progbits
结论
编译器并不是把函数模板处理成能够处理任意类型的函数编译器从函数模板通过具体类型产生不同的函数
类模板的使用
为什么需要类模板
1.为什么需要类模板
类模板与函数模板的定义和使用类似有时有两个或多个类其功能是相同的仅仅是数据类型不同我们可以通过如下面语句声明了一个类模板
// demo 15-7.c
template typename T
class A
{
public:A(T t){this-t t;}T getT(){return t;}public:T t;
};
Ø 类模板用于实现类所需数据的类型参数化
Ø 类模板在表示支持多种数据结构显得特别重要这些数据结构的表示和算法不受所包含的元素类型的影响
类模板的定义
类模板由模板说明和类说明构成
模板说明同函数模板如下
*template* 类型形式参数表
类声明 例如 template class ClassName { //ClassName 的成员函数 private Type DataMember; } 单个类模板的使用
// demo 15-8.c
#include iostreamusing namespace std;template typename T
class A
{
public://函数的参数列表使用虚拟类型A(T t0){this-t t;}//成员函数返回值使用虚拟类型T getT(){return t;}private://成员变量使用虚拟类型T t;
};void printA(Aint a){couta.getT()endl;
}int main(void){//1.模板类定义类对象必须显示指定类型//2.模板种如果使用了构造函数则遵守以前的类的构造函数的调用规则Aint a(666);couta.getT()endl;//模板类做为函数参数printA(a);system(pause);return 0;
}
继承中类模板的使用
// demo 15-9.c
#include iostreamusing namespace std;//继承中父子类和模板类的结合情况
//1.父类一般类子类是模板类, 和普通继承的玩法类似
//2.子类是一般类父类是模板类,继承时必须在子类里实例化父类的类型参数
//3.父类和子类都时模板类时子类的虚拟的类型可以传递到父类中/*class B
{
public:B(int b){this-b b;}private:int b;
};
*/template typename T
class A
{
public://函数的参数列表使用虚拟类型A(T t){this-t t;}//成员函数返回值使用虚拟类型T getT(){return t;}private://成员变量使用虚拟类型T t;
};template typename Tb
class B: public Aint
{public:B(Tb b):ATb(b){this-b b;}private:Tb b;};void printA(Aint a){couta.getT()endl;
}int main(void){//1.模板类定义类对象必须显示指定类型//2.模板种如果使用了构造函数则遵守以前的类的构造函数的调用规则Aint a(666);couta.getT()endl;Bint b(888);coutb(888): b.getT()endl;//模板类做为函数参数printA(a);system(pause);return 0;
}
结论: 子类从模板类继承的时候,需要让编译器知道 父类的数据类型具体是什么
1.父类一般类子类是模板类, 和普通继承的玩法类似
2.子类是一般类父类是模板类,继承时必须在子类里实例化父类的类型参数
3.父类和子类都时模板类时子类的虚拟的类型可以传递到父类中
类模板的三种表述方式
所有的类模板函数写在类的外部在一个cpp中
// demo 15-9.c
#include iostreamusing namespace std;template typename T
class A
{
public:A(T t0);T getT();A operator (const A other);void print();private:T t;
};/*
class A
{
public:A(int t0);int getT();A operator (const A other);void print();private:int t;
};
*/template typename T
AT::A(T t)
{this-t t;
}template typename T
T AT::getT(){return t;}template typename T
AT AT::operator(const AT other){AT tmp; //类的内部类型可以显示声明也可以不显示tmp.t this-t other.t;return tmp;}template typename T
void AT::print(){coutthis-tendl;
}int main(void){Aint a(666), b(888);//couta.getT()endl;Aint tmp a b;tmp.print();system(pause);return 0;
} 总结
在同一个cpp 文件中把模板类的成员函数放到类的外部需要注意以下几点 函数前声明 *template* 类型形式参数表 类的成员函数前的类限定域说明必须要带上虚拟参数列表 返回的变量是模板类的对象时必须带上虚拟参数列表 成员函数参数中出现模板类的对象时必须带上虚拟参数列表 成员函数内部没有限定
所有的类模板函数写在类的外部在不同的.h和.cpp中
// demo.h
#pragma oncetemplate typename T
class A
{
public:A(T t0);T getT();A operator (const A other);void print();private:T t;
};
// demo 15-10.c
#include demo.h
#include iostreamusing namespace std;template typename T
AT::A(T t)
{this-t t;
}template typename T
T AT::getT(){return t;}template typename T
AT AT::operator(const AT other){AT tmp; //类的内部类型可以显示声明也可以不显示tmp.t this-t other.t;return tmp;}template typename T
void AT::print(){coutthis-tendl;
}int main(void){Aint a(666), b(888);//couta.getT()endl;Aint tmp a b;tmp.print();system(pause);return 0;
}****注意****当类模板的声明(.h文件)和实现(.cpp 或.hpp文件)完全分离因为类模板的特殊实现我们应在使用类模板时使用#include 包含 实现部分的.cpp 或.hpp文件。
特殊情况- 友元函数
// demo 15-11.c
#include iostreamusing namespace std;template typename T
class A
{
public:A(T t0);//声明一个友元函数实现对两个A类对象进行加法操作template typename Tfriend AT addA(const AT a, const AT b);T getT();A operator (const A other);void print();private:T t;
};template typename T
AT::A(T t)
{this-t t;
}template typename T
T AT::getT(){return t;}template typename T
AT AT::operator(const AT other){A tmp; //类的内部类型可以显示声明也可以不显示tmp.t this-t other.t;return tmp;}template typename T
void AT::print(){coutthis-tendl;
}//A 类的友元函数,就是它的好朋友
template typename T
AT addA(const AT a, const AT b){AT tmp;coutcall addA()...endl;tmp.t a.t b.t;return tmp;
}int main(void){Aint a(666), b(888);//couta.getT()endl;Aint tmp a b;Aint tmp1 addAint(a, b);tmp.print();tmp1.print();system(pause);return 0;
} 模板类和静态成员
// demo 15-12.c
#include iostreamusing namespace std;template typename T
class A
{
public:A(T t0);T getT();A operator (const A other);void print();public:static int count;
private:T t;
};template typename T int AT::count 666;template typename T
AT::A(T t)
{this-t t;
}template typename T
T AT::getT()
{return t;
}template typename T
AT AT::operator(const AT other){A tmp; //类的内部类型可以显示声明也可以不显示tmp.t this-t other.t;return tmp;
}template typename T
void AT::print(){coutthis-tendl;
}/*
//当我们的虚拟的类型T被 int 实例化以后模板类如下
class A
{
public:
A(int t0);int getT();A operator (const A other);void print();public:
static int count;
private:
int t;
};int A::count 666;A::A(int t)
{
this-t t;
}int A::getT()
{
return t;
}A A::operator(const A other){
A tmp; //类的内部类型可以显示声明也可以不显示
tmp.t this-t other.t;
return tmp;
}void A::print(){
coutthis-tendl;
}
*//*
//当我们的虚拟的类型T被 float 实例化以后模板类如下
class A
{
public:
A(float t0);float getT();A operator (const A other);void print();public:
static int count;
private:
float t;
};int A::count 666;A::A(float t)
{
this-t t;
}float A::getT()
{
return t;
}A A::operator(const A other){
A tmp; //类的内部类型可以显示声明也可以不显示
tmp.t this-t other.t;
return tmp;
}void A::print(){
coutthis-tendl;
}
*/int main(void){Aint a(666), b(888);Aint tmp a b;//A a(666), b(888);//A tmp a b;Afloat c(777), d(999);a.count 888;coutb.count:b.countendl;coutc.count:c.countendl;coutd.count:d.countendl;c.count 1000;cout修改后, d.count:d.countendl;//tmp.print();system(pause);return 0;
}类模板使用总计
归纳以上的介绍可以这样声明和使用类模板 先写出一个实际的类。 将此类中准备改变的类型名(如int要改变为float或char)改用一个自己指定的虚拟类型名(如上例中的T)。 在类声明前面加入一行格式为 template typename 虚拟类型参数
如 template typename numtype class A{…}; //类体用类模板定义对象时用以下形式 类模板名实际类型名 对象名; 或 类模板名实际类型名 对象名(实参表列);
如
Aint cmp;Aint cmp(3,7);如果在类模板外定义成员函数应写成类模板形式 template typename 虚拟类型参数 函数类型 类模板名虚拟类型参数::成员函数名(函数形参表列) { …}
关于类模板的几点 补充 类模板的类型参数可以有一个或多个每个类型前面都必须加typename 或class如 template typename T1,typename T2 class someclass {…};
在定义对象时分别代入实际的类型名如 someclassint, char object;和使用类一样使用类模板时要注意其作用域只有在它的有效作用域内用使用它定义对象。 模板类也可以有支持继承有层次关系一个类模板可以作为基类派生出派生模板类。
