模板_模板匹配 - CSDN
模板 订阅
模板,是指作图或设计方案的固定格式,有时也指DNA复制或转录时,用来产生互补链的核苷酸序列。模板是将一个事物的结构规律予以固定化、标准化的成果,它体现的是结构形式的标准化。 展开全文
模板,是指作图或设计方案的固定格式,有时也指DNA复制或转录时,用来产生互补链的核苷酸序列。模板是将一个事物的结构规律予以固定化、标准化的成果,它体现的是结构形式的标准化。
信息
意    思
使物体成固定型状的模具
拼    音
mú bǎn
中文名
模板
外文名
Template
模板词语信息
mú bǎn使物体成固定型状的模具。模板是新浇混凝土成型用的模型,模板系统由模板、支承件和紧固件组成,要求它能保证结构和构件的形状尺寸准确;有足够的强度、刚度和稳定性;装拆方便可多次使用;接缝严密不漏浆。常用的模板包括木模板、定型组合模板、大型工具式的大模板、爬模、滑升模板、隧道模、台模(飞模、桌模)、永久式模板等。mó bǎn模板指集散控制系统(DCS)中的功能模件,因为大小比模块大,呈板状,所以叫做模板。模板 (template)【分子生物学】模板为核酸中的碱基序列,它可用作DNA或RNA互补链合成的基础。【理论免疫学】是指决定抗体分子结合部位构型的抗原。【遗传学】是指一条DNA单链,是合成RNA互补链或mRNA的模板,又是合成核酸或蛋白质的模板。【网络】在ASP.NET中:一个声明性页段落,用于为模板化的 ASP.NET 服务器控件提供可视化界面。模板包含表示元素,这些元素包括文本文字、HTML 和数据绑定表达式,以及表示 ASP.NET服务器控件的声明性语法元素。模板可以作为带有 .ascx 扩展名的文本文件持续。【工业】指生产、合成重复产物的模子。【建筑】formwork混凝土结构或钢筋混凝土结构成型的模具,由面板和支撑系统(包括龙骨、桁架、小梁等,以及垂直支承结构)、连接配件(包括螺栓、联结卡扣、模板面与支承构件以及支承构件之间联结零、配件)组成。模板按材料分为:钢模板,竹胶板,木模板,塑胶板。竹胶板一般都是一次性的,而其他模板则可以刷上脱模剂、模板漆,以此延长模板的寿命,浇注出高质量的墩柱。模板按其功能分五大类:定型组合模板、一般木模板+钢管(或木立柱支撑)、墙体大模板、飞模(台模)、滑动模板。【 Microsoft Office办公软件】模板是指一个或多个文件,其中所包含的结构和工具构成了已完成文件的样式和页面布局等元素。例如,Word 模板能够生成单个文档,而 FrontPage 模板可以形成整个网站。【面向对象程序设计】模板是建立通用的与数据类型无关的算法的重要手段。C++国际标准ISO 14882将模板正式引入标准库,要求用模板类取代传统C++中定义的类。【 网站】在网上都会有各类网站管理系统提供下载,例如用PHP语言编写的织梦网站管理系统,再或者ASP语言编写的动易、新云等,大家可以通过这些网站管理系统轻松架设网站,这些网站都有自己的模板,叫网站管理系统模板,简称“网站模板”。【集散控制系统(DCS)】moduleDCS内,较模块大的模件,叫做模板。
收起全文
精华内容
参与话题
  • C++:模板总结

    万次阅读 多人点赞 2019-03-16 12:34:26
    写在前面     &...模板(Template)指C++程序设计设计...模板是C++支持参数化多态的工具,使用模板可以使用户为类或者函数声明一种一般模式,使得类中的某些数据成员或者成...

    写在前面

            模板(Template)指C++程序设计设计语言中采用类型作为参数的程序设计,支持通用程序设计。C++ 的标准库提供许多有用的函数大多结合了模板的观念,如STL以及IO Stream。模板是C++支持参数化多态的工具,使用模板可以使用户为类或者函数声明一种一般模式,使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。

    模板是一种对类型进行参数化的工具;

    通常有两种形式:函数模板和类模板;

    函数模板 针对仅参数类型不同的函数;
    类模板 针对仅数据成员和成员函数类型不同的类。

    使用模板的目的就是能够让程序员编写与类型无关的代码。

    1.函数模板

     template <class 形参名,class 形参名,......> 
     返回类型 函数名(参数列表)
    
       {
    
          函数体
    
       }
    

    其中template和class是关键字,class可以用typename 关键字代替,在这里typename 和class没区别,<>括号中的参数叫模板形参,模板形参和函数形参很相像,模板形参不能为空。一但声明了模板函数就可以用模板函数的形参名声明类中的成员变量和成员函数,即可以在该函数中使用内置类型的地方都可以使用模板形参名。模板形参需要调用该模板函数时提供的模板实参来初始化模板形参,一旦编译器确定了实际的模板实参类型就称他实例化了函数模板的一个实例。比如swap的模板函数形式为

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

    当调用这样的模板函数时类型T就会被被调用时的类型所代替,比如swap(a,b)其中a和b是int 型,这时模板函数swap中的形参T就会被int 所代替,模板函数就变为swap(int &a, int &b)。而当swap(c,d)其中c和d是double类型时,模板函数会被替换为swap(double &a, double &b),这样就实现了函数的实现与类型无关的代码。

    注意:对于函数模板而言不存在 h(int,int) 这样的调用,不能在函数调用的参数中指定模板形参的类型,对函数模板的调用应使用实参推演来进行,即只能进行 h(2,3) 这样的调用,或者int a, b; h(a,b)。

    2.类模板

    1、类模板的格式为:

        template<class  形参名,class 形参名,…>
        class 类名{ ... };
    

    类模板和函数模板都是以template开始后接模板形参列表组成,模板形参不能为空,一但声明了类模板就可以用类模板的形参名声明类中的成员变量和成员函数,即可以在类中使用内置类型的地方都可以使用模板形参名来声明。比如

        template<class T> class A
        {
           public: 
           T a;
           T b; 
           T hy(T c, T &d);
           };
    

    在类A中声明了两个类型为T的成员变量a和b,还声明了一个返回类型为T带两个参数类型为T的函数hy。

    2、类模板对象的创建:比如一个模板类A,则使用类模板创建对象的方法为A m;在类A后面跟上一个<>尖括号并在里面填上相应的类型,这样的话类A中凡是用到模板形参的地方都会被int 所代替。当类模板有两个模板形参时创建对象的方法为A<int, double> m;类型之间用逗号隔开。

    3、对于类模板,模板形参的类型必须在类名后的尖括号中明确指定。比如A<2> m;用这种方法把模板形参设置为int是错误的(编译错误:error C2079: ‘a’ uses undefined class ‘A’),类模板形参不存在实参推演的问题。也就是说不能把整型值2推演为int 型传递给模板形参。要把类模板形参调置为int 型必须这样指定A m。

    4、在类模板外部定义成员函数的方法为:

    template<模板形参列表> 函数返回类型 类名<模板形参名>::函数名(参数列表){函数体}
    

    比如有两个模板形参T1,T2的类A中含有一个void h()函数,则定义该函数的语法为:

        template<class T1,class T2> void A<T1,T2>::h(){}

    注意:当在类外面定义类的成员时template后面的模板形参应与要定义的类的模板形参一致。

    5、再次提醒注意:模板的声明或定义只能在全局,命名空间或类范围内进行。即不能在局部范围,函数内进行,比如不能在main函数中声明或定义一个模板。

    3.模板的非类型形参

    1 、非类型模板形参:模板的非类型形参也就是内置类型形参,如template<class T, int a> class B{};其中int a就是非类型的模板形参。

    2、 非类型形参在模板定义的内部是常量值,也就是说非类型形参在模板的内部是常量。

    3、 非类型模板的形参只能是整型,指针和引用,像double,String, String **这样的类型是不允许的。但是double &,double *,对象的引用或指针是正确的。

    4、 调用非类型模板形参的实参必须是一个常量表达式,即他必须能在编译时计算出结果。

    5 、注意:任何局部对象,局部变量,局部对象的地址,局部变量的地址都不是一个常量表达式,都不能用作非类型模板形参的实参。全局指针类型,全局变量,全局对象也不是一个常量表达式,不能用作非类型模板形参的实参。

    6、 全局变量的地址或引用,全局对象的地址或引用const类型变量是常量表达式,可以用作非类型模板形参的实参。

    7 、sizeof表达式的结果是一个常量表达式,也能用作非类型模板形参的实参。

    8 、当模板的形参是整型时调用该模板时的实参必须是整型的,且在编译期间是常量,比如template <class T, int a> class A{};如果有int b,这时A<int, b> m;将出错,因为b不是常量,如果const int b,这时A<int, b> m;就是正确的,因为这时b是常量。

    9 、非类型形参一般不应用于函数模板中,比如有函数模板template<class T, int a> void h(T b){},若使用h(2)调用会出现无法为非类型形参a推演出参数的错误,对这种模板函数可以用显示模板实参来解决,如用h<int, 3>(2)这样就把非类型形参a设置为整数3。显示模板实参在后面介绍。

    10、 非类型模板形参的形参和实参间所允许的转换
          1、允许从数组到指针,从函数到指针的转换。如:template <int *a> class A{}; int b[1]; A m;即数组到指针的转换
          2、const修饰符的转换。如:template<const int *a> class A{}; int b; A<&b> m; 即从int *到const int *的转换。
          3、提升转换。如:template class A{}; const short b=2; A m; 即从short到int 的提升转换
          4、整值转换。如:template class A{}; A<3> m; 即从int 到unsigned int的转换。
          5、常规转换。

    4.类模板的默认模板类型形参

    1、可以为类模板的类型形参提供默认值,但不能为函数模板的类型形参提供默认值。函数模板和类模板都可以为模板的非类型形参提供默认值。

    2、类模板的类型形参默认值形式为:template<class T1, class T2=int> class A{};为第二个模板类型形参T2提供int型的默认值。

    3、类模板类型形参默认值和函数的默认参数一样,如果有多个类型形参则从第一个形参设定了默认值之后的所有模板形参都要设定默认值,比如templateclass A{};就是错误的,因为T1给出了默认值,而T2没有设定。

    4、在类模板的外部定义类中的成员时template 后的形参表应省略默认的形参类型。比如template<class T1, class T2=int> class A{public: void h();}; 定义方法为template<class T1,class T2> void A<T1,T2>::h(){}。

    5.模板的实例化

    总结一下,C++只有模板显式实例化(explicit instantiation),隐式实例化(implicit instantiation),特化(specialization,也译作具体化,偏特化)。首先考虑如下模板函数代码:

    [cpp] view plaincopyprint?
    template <typename T>  
    void swap(T &a, T &b){  
    ...  
    }  
    

    1.隐式实例化
    我们知道,模板函数不是真正的函数定义,他只是如其名提供一个模板,模板只有在运行时才会生成相应的实例,隐式实例化就是这种情况:

    [cpp] view plaincopyprint?
    int main(){  
        ....  
        swap<int>(a,b);  
        ....  
    }  
    

    它会在运行到这里的时候才生成相应的实例,很显然的影响效率
    这里顺便提一下swap(a,b);中的是可选的,因为编译器可以根据函数参数类型自动进行判断,也就是说如果编译器不不能自动判断的时候这个就是必要的;

    2.显式实例化

    前面已经提到隐式实例化可能影响效率,所以需要提高效率的显式实例化,显式实例化在编译期间就会生成实例,方法如下:

    [cpp] view plaincopyprint?
    template void swap<int>(int &a,int &b);  
    

    这样就不会影响运行时的效率,但编译时间随之增加。

    3.特化

    这个swap可以处理一些基本类型如long int double,但是如果想处理用户自定义的类型就不行了,特化就是为了解决这个问题而出现的:

    [cpp] view plaincopyprint?
    template <> void swap<job>(job a,job b){...}  
    

    其中job是用户定义的类型.

    6.模板的特化(具体化)和偏特化

    类模板:

    测试代码如下:
    
    #include <iostream>
    using namespace std;
    template<typename T1,typename T2>
    class Test{
    public:
        Test(T1 i,T2 j):a(i),b(j){cout<<"模板类"<<endl;}
    private:
        T1 a;
        T2 b;
    };
    template<>   //全特化,由于是全特化,参数都指定了,参数列表故为空。
    class Test<int ,char>{
    public:
        Test(int i,char j):a(i),b(j){cout<<"全特化"<<endl;}
    private:
        int a;
        int b;
    };
    template<typename T2> //由于只指定了一部分参数,剩下的未指定的需在参数列表中,否则报错。
    class Test<char,T2>{
    public:
        Test(char i,T2 j):a(j),b(j){cout<<"个数偏特化"<<endl;}
    private:
        char a;
        T2 b;
    };
    template<typename T1,typename T2> //这是范围上的偏特化
    class Test<T1*,T2*>{
    public:
        Test(T1* i,T2* j):a(i),b(j){cout<<"指针偏特化"<<endl;}
    private:
        T1* a;
        T2* b;
    };
    template<typename T1,typename T2>//同理这也是范围上的偏特化
    class Test<T1 const,T2 const>{
    public:
        Test(T1 i,T2 j):a(i),b(j){cout<<"const偏特化"<<endl;}
    private:
        T1 a;
        T2 b;
    };
    int main()
    {
        int a;
        Test<double,double> t1(0.1,0.2);
        Test<int,char> t2(1,'A');
        Test<char,bool> t3('A',true);
        Test<int*,int*> t4(&a,&a);
        Test<const int,const int> t5(1,2);
        return 0;
    }
    

    运行结果截图:
    在这里插入图片描述
    函数模板:
    而对于函数模板,却只有全特化,不能偏特化:

    #include <iostream>
    using namespace std;
    //模板函数
    template<typename T1,typename T2>
    void fun(T1 a,T2 b){
        cout<<"模板函数"<<endl;
    }
    //全特化
    template<>
    void fun(int a,char b){
        cout<<"全特化"<<endl;
    }
    //函数不存在偏特化,以下代码是错误的
    /*
    template<typename T2>
    void fun(char a,T2 b){
        cout<<"偏特化"<<ednl;
    }
    */
    int main()
    {
        int a=0;
        char b='A';
        fun(a,a);
        fun(a,b);
        return 0;
    }
    

    运行截图如下:
    在这里插入图片描述

    7.模板类的继承

    模板类的继承包括四种:

    1.(普通类继承模板类)

    2.(模板类继承了普通类(非常常见))

    3.(类模板继承类模板)

    4.(模板类继承类模板,即继承模板参数给出的基类)

    其中,普通类继承模板类比较简单,如

    1 template<class T>
    2 class TBase{
    3     T data;
    4 ……
    5 };
    6 class Derived:public TBase<int>{
    7 ……
    8 };
    

    模板类继承普通类:

    1 class TBase{
    2 ……
    3 };
    4 template<class T>
    5 class TDerived:public TBase{
    6 T data;
    7 ……
    8 };
    

    类模板继承类模板:

     1 template<class T>
     2 class TBase{
     3 T data1;
     4 ……
     5 };
     6 template<class T1,class T2>
     7 class TDerived:public TBase<T1>{
     8 T2 data2;
     9 ……
    10 };
    
    1. 模板类继承模板参数给出的基类
      ——继承哪个基类由模板参数决定
    #include<iostream>
    using namespace std;
    
    
    class BaseA{
    public:
        BaseA(){cout<<"BaseA founed"<<endl;}
    };
    
    class BaseB{
    public:
        BaseB(){cout<<"BaseB founed"<<endl;}
    };
    
    template<typename T, int rows>
    class BaseC{
    private:
        T data;
    public:
        BaseC():data(rows){
            cout<<"BaseC founed "<< data << endl;}
    };
    
    template<class T>
    class Derived:public T{
    public:
        Derived():T(){cout<<"Derived founed"<<endl;}
    };
    
    
    void main()
    {
        Derived<Base A> x;// BaseA作为基类
        Derived<Base B> y;// BaseB作为基类
        Derived<Base C<int, 3> > z; // BaseC<int,3>作为基类
        
    

    模板实例化问题:

            在我们使用类模板时,只有当代码中使用了类模板的一个实例的名字,而且上下文环境要求必须存在类的定义时,这个类模板才被实例化。

    1.声明一个类模板的指针和引用,不会引起类模板的实例化,因为没有必要知道该类的定义。

    2.定义一个类类型的对象时需要该类的定义,因此类模板会被实例化。

    3.在使用sizeof()时,它是计算对象的大小,编译器必须根据类型将其实例化出来,所以类模板被实例化.

    4.new表达式要求类模板被实例化。

    5.引用类模板的成员会导致类模板被编译器实例化。

    6.需要注意的是,类模板的成员函数本身也是一个模板。标准C++要求这样的成员函数只有在被调用或者取地址的时候,才被实例化。用来实例化成员函数的类型,就是其成员函数要调用的那个类对象的类型

    展开全文
  • 18种经典网站模板

    2020-07-28 12:57:44
    从以前下载的200多个网站模板整理出来的,个人认为比较好的模板,分享给大家,整来整去就留下了18个,多了感觉也是浪费大家的资源,基本以静态为主(div+css,js),也有一个asp+access的,希望给大家有所帮助,别像...
  • 十一个精美的网站模板,一般够用,欢迎下载
  • select rownum*3 as rk, '/** 注释*/' from dual connect by rownum<=7 union all select rownum*3+2 as rk, null from dual connect by rownum<=7 union all select rownum*3 as rk , ...
    select rownum*3 as rk, '/** 注释*/' from dual connect by rownum<=7
    
    union all
    
    select rownum*3+2 as rk, null from dual connect by rownum<=7
    
    union all
    
    select rownum*3 as rk ,
        'public static final String '
        || replace(column_name,'_','') 
        || ' = "' 
        || lower(column_name) 
        || '";' 
    from user_tab_columns 
    where table_name='emp'
    order by rk
    ;
    select 'map.put('|| replace(column_name,'_','')||',rs.getLong('||rownum||'));'  
    from user_tab_columns 
    where table_name='emp'
    
    --还可以添加类型
    select 'map.put('|| replace(column_name,'_','')||',rs.get'
    || decode(DATA_TYPE,'NUMBER','Long','VARCHAR2','String')
    ||'('||rownum||'));'  
    from user_tab_columns 
    where table_name='emp'

     

    参考地址:

    https://mp.csdn.net/console/editor/html/108409288 (oracle 函数)

     

    展开全文
  • 模板(Template)模式

    千次阅读 2019-05-30 23:19:13
    模板方法使得子类可以在不改变算法结构的情况下,重新定义算法中的某些步骤 使用场景 当要完成一件事情,它有固定的程序流程,但某些步骤是自定义的,使用模板方法 当需要创建框架时,在超类中提供一个基础的方法...

    概念

    一个方法中定义一个算法的骨架,而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下,重新定义算法中的某些步骤

    使用场景

    1. 当要完成一件事情,它有固定的程序流程,但某些步骤是自定义的,使用模板方法
    2. 当需要创建框架时,在超类中提供一个基础的方法,达到代码的复用,并允许子类指定行为

    示例:

    //抽象类
    public abstract class templateClass {
    
        //模板方法,用final修饰,不允许子类覆盖。模板方法定义了流程(算法) a->b->c
        final void templateFun(){
            a();
            b();
            c();
        }
         
        //a步骤
        void a(){
             System.out.println("第一步: a");
        }
         
        //b步骤 抽象方法:子类必须实现
        abstract void b();
         
        //c
        void soak(){
            System.out.println("第三步: c");
        }
    }
    

    子类one实现

    public class One extends templateClass{
        @Override
        void b() {
            System.out.println("第二步: one-b");
        }
    }
    

    子类two实现

    public class Two extends templateClass{
        @Override
        void b() {
            System.out.println("第二步: two-b");
        }
    }
    

    测试

    public class Test {
        public static void main(String[] args){
          
            System.out.println("one步骤 a->b->c");
            templateClass oneTemplateClass = new One();
            oneTemplateClass.templateFun();
             
            System.out.println("two步骤 a->b->c");
            templateClass twoTemplateClass = new Two();
            twoTemplateClass.templateFun();
        }
    }
    

    模板模式之钩子方法

    //抽象类
    public abstract class templateClass {
    
        //模板方法,用final修饰,不允许子类覆盖。模板方法定义了流程(算法) a->b->c
        final void templateFun(){
            a();
            b();
            if(isRunC()){
               c(); 
            }
        }
         
        //a步骤
        void a(){
             System.out.println("第一步: a");
        }
         
        //b步骤 抽象方法:子类必须实现
        abstract void b();
         
        //c
        void soak(){
            System.out.println("第三步: c");
        }
        
        //钩子方法,是否执行c步骤
        boolean isRunC(){
            return true;
        }
    }
    

    子类one实现

    public class One extends templateClass{
        @Override
        void b() {
            System.out.println("第二步: one-b");
        }
        覆盖钩子方法
        @Override
        boolean isRunC(){
            return false;
        }
    }
    

    子类two实现

    public class Two extends templateClass{
        @Override
        void b() {
            System.out.println("第二步: two-b");
        }
        //覆盖钩子方法
        @Override
        boolean isRunC(){
            return true;
        }
    }
    

    测试

    public class Test {
        public static void main(String[] args){
          
            System.out.println("one步骤 a->b->c");
            templateClass oneTemplateClass = new One();
            oneTemplateClass.templateFun();
             
            System.out.println("two步骤 a->b->c");
            templateClass twoTemplateClass = new Two();
            twoTemplateClass.templateFun();
        }
    }
    
    展开全文
  • 这是project常用模板的集合,包括企业信息化项目群,视频保安系统项目,项目变更案例(变更后),项目变更案例(变更前),项目计划变更记录,项目群案例,优化类项目计划模板,邮件系统合并项目,全是.mpp格式的...
  • 模板模板

    万次阅读 多人点赞 2019-07-04 21:10:42
    模板模板类 所谓类模板,实际上是建立一个通用类,其数据成员、成员函数的返回值类型和形参类型不具体指定,用一个虚拟的类型来代表。使用类模板定义对象时,系统会实参的类型来取代类模板中虚拟类型从而实现了...

    类模板和模板类

    所谓类模板,实际上是建立一个通用类,其数据成员、成员函数的返回值类型和形参类型不具体指定,用一个虚拟的类型来代表。使用类模板定义对象时,系统会实参的类型来取代类模板中虚拟类型从而实现了不同类的功能。

    定义一个类模板与定义函数模板的格式类似,必须以关键字template开始,后面是尖括号括起来的模板参数,然后是类名,其格式如下:

    template <typename 类型参数>
    class 类名{
           类成员声明 
    };
    
    或者
    
    template <class 类型参数>
    class 类名{
           类成员声明 
    };
    
    1. template:是一个声明模板的关键字,它表明声明一个模板

    2. 类型参数:通常用C++标识符表示,如T、Type等,实际上是一个虚拟的类型名,现在未指定它是哪一种具体的类型,但使用类模板时,必须将类型参数实例化。

    3. typename和class的作用相同,都是表示其后面的参数是一个虚拟的类名(即类型参数).

    在类声明中,欲采用通用数据类型的数据成员、成员函数的参数或返回类型前面需要加上类型参数。

    如建立一个用来实现求两个数最大值的类模板

    template<typename T>    //模板声明,其中T为类型参数
        class Compare{
          public:
           Compare(T i,T j)
           {
            x = i;
            y = j;
           }
           T max()
           {
            return (x>y)?x:y;
           } 
          private:
           T x,y; 
        };
    

    用类模板定义对象时,采用以下形式:

    类模板名<实际类型名>对象名[(实参表列)];
    

    因此,使用上面求最大值的类型模板的主函数可写成:

     int main()
         {
          Compare<int>com1(3,7);
          Compare<double>com2(12.34,56.78);
          Compare<char>com3('a','x');
          cout<<"其中的最大值是:"<<com1.max()<<endl;
          cout<<"其中的最大值是:"<<com2.max()<<endl;
          cout<<"其中的最大值是:"<<com3.max()<<endl;
          return  0;
         }    
    

    例6.6 类模板compare的使用举例

    #include<iostream.h>
    template<typename T>    //模板声明,其中T为类型参数
    class Compare{
      public:
        Compare(T i,T j)
        {
          x = i;
          y = j;
        }
        T max()
         {
          return (x>y)?x:y;
         } 
     private:
        T x,y; 
    };
    int main()
    {
    Compare<int>com1(3,7);                       //用类模板定义对象com1,此时T被int替代 
    Compare<double>com2(12.34,56.78);            //用类模板定义对象com2,此时T被double替代 
    Compare<char>com3('a','x');                  //用类模板定义对象com3,此时T被char替代 
    cout<<"其中的最大值是:"<<com1.max()<<endl;   
    cout<<"其中的最大值是:"<<com2.max()<<endl;
    cout<<"其中的最大值是:"<<com3.max()<<endl;
    return  0;
    }
    

    程序运行结果是:

    其中的最大值是:7
    其中的最大值是:56.78
    其中的最大值是:x        
    

    在以上例子中,成员函数(其中含有类型参数)是定义类体内的。但是,类模板中的成员函数,也可以在类模板外定义。此时,若成员函数中有参数类型存在,则C++有一些特殊的规定:

    (1)需要在成员函数定义之前进行模板声明;
    (2)在成员函数名前缀上"类名<类型参数>::";
    

    在类模板外定义成员函数的一般形式如下:

    temlate<typename 类型参数>
      函数类型 类名<类型参数>::成员函数名(形参表)
      {
        函数体; 
       }
       
       如上题中成员函数max在类模板外定义时,应该写成:
       template<typename T>
       T Compare<T>::max()
       {
        return (x>y)?x:y;
       } 
    

    //例6.7 在类模板外定义成员函数函数举例。

    #include<iostream.h>
    template<typename T>    //模板声明,其中T为类型参数
    class Compare{
      public:
        Compare(T i,T j)
        {
          x = i;
          y = j;
        }
        T max(); 
     private:
        T x,y; 
    };
    template<class T>
    T Compare<T>::max()
    {
     return (x>y)?x:y;
    }
    int main()
    {
    Compare<int>com1(3,7);                       //用类模板定义对象com1,此时T被int替代 
    Compare<double>com2(12.34,56.78);            //用类模板定义对象com2,此时T被double替代 
    Compare<char>com3('a','x');                  //用类模板定义对象com3,此时T被char替代 
    cout<<"其中的最大值是:"<<com1.max()<<endl;   
    cout<<"其中的最大值是:"<<com2.max()<<endl;
    cout<<"其中的最大值是:"<<com3.max()<<endl;
    return  0;
    } 
    

    /*
    程序运行结果是:

        其中的最大值是:7
        其中的最大值是:56.78
        其中的最大值是:x
    

    此例中,类模板Compare经实例化后生成了3个类型分别为int、double、char的模板类,这3个模板类
    经实例化后又生成了3个对象com1、com2、com3。类模板代表了一类类,模板类表示某一具体的类。关系如下:

                                             类模板
                                            Compare<T>
        实例化成模板类:Compare<int>       Compare<double>     Compare<char>
        实例化模板类对象:com1                 com2                com3
    

    例6.8 类模板Stack的使用举例。

    #include<iostream.h>
    const int size=10;
    template<class T>                     //模板声明,其中T为类型参数 
    class Stack{                          //类模板为Stack 
     public:
      void init()
      {
       tos=0;
      }
      void push(T ob);                    //声明成员函数push的原型,函数参数类型为T类型
      T pop();                            //声明成员函数pop的原型,其返回值类型为T类型
     private:
      T stack[size];                      //数组类型为T,即是自可取任意类型 
      int tos; 
    };
    template<class T>                     //模板声明 
    void Stack<T>::push(T ob)             //在类模板体外定义成员函数push 
    {
      if(tos==size)
       {
        cout<<"Stack is full"<<endl;
        return;
       }
      stack[tos]=ob;
      tos++; 
    }
    template<typename T>                  //模板声明 
    T Stack<T>::pop()                               //在类模板体外定义成员函数push
    {
      if(tos==0)
       {
        cout<<"Stack is empty"<<endl;
        return 0;
       }
      tos--; 
      return stack[tos];  
    }
    int main()
    {
     //定义字符堆栈 
     Stack<char> s1;                        //用类模板定义对象s,此时T被char取代
     s1.init();
     s1.push('a');
     s1.push('b');
     s1.push('c'); 
     for(int i=0;i<3;i++){cout<<"pop s1:"<<s1.pop()<<endl;}
     
     //定义整型堆栈 
     Stack<int> s2;                        //用类模板定义对象s,此时T被int取代
     s2.init();
     s2.push(1);
     s2.push(3);
     s2.push(5); 
     for(int i=0;i<3;i++){cout<<"pop s2:"<<s2.pop()<<endl;} 
     
     return 0; 
    }
    

    /*
    程序运行结果是:

    pop s1:c
    pop s1:b
    pop s1:a
    pop s2:5
    pop s2:3
    pop s2:1 
    

    说明:

    1. 在每一个类模板定义之前,都需要在前面加上模板声明,如

      template

      template
      并且,类模板在使用时,必须在模板类名字后面缀上<类型参数> ,如
      Stack

    2. 如同模板函数一样,模板类也可以有多个类型参数。

    例6.9 有两个类型参数的类模板举例

    #include<iostream.h>
    template<class QQ,class T>                    //声明模板,具有T1,T2两个类型参数 
    class Myclass{                                 //定义模板类Myclass 
      public:
       Myclass(QQ a,T b);
       void show();
      private:
       QQ x;
       T y;
    };
    template<typename QQ,typename T>
    Myclass<QQ,T>::Myclass(QQ a,T b)
    {
     x = a;
     y = b;
    }
    template<class QQ,class T>
    void Myclass<QQ,T>::show()
    {
     cout<<"x="<<x<<","<<"y="<<y<<endl;
    }
    int main()
    {
     Myclass <int,double>m1(12,0.15);               //用类模板定义对象m1,此时T1,T2分别被int、double取代 
     Myclass <int,char*>m2(12,"This a test.");      //用类模板定义对象m2,此时T1,T2分别被int,char*取代
    
     m1.show();
     m2.show();
     
     return 0; 
    }
    /*
    程序运行结果是:
    x=12,y=0.15
    x=12,y=This a test. 
    */
    

    程序猿神奇的手,每时每刻,这双手都在改变着世界的交互方式!
    更多C++相关知识体系,请移步C++知识目录

    展开全文
  • C++模板简介与使用

    千次阅读 多人点赞 2018-06-27 10:55:13
    模板简介与使用扯一扯模板以及简单的运用1.模板概述利用 C++ 模板,您可以定义可对不同类型的信息运行的一系列函数或类。 Microsoft C++ 模板的实现基于 ISO/ANSI C++ 标准。在导致重复多个类型的同一代码的情况下应...
  • C/C++模板

    千次阅读 2019-02-14 12:14:34
    函数模板 在一个int 型数组中,查找最大的数… 在一个double 型数组中,查找最大的数… 在一个float 型数组中,查找最大的数… 在一个Objext[] 型数组中,查找最大的数… 算法都是一样的:遍历数组,找出最大的...
  • C++模板

    千次阅读 2019-06-09 16:56:37
    模板是C++中泛型编程的基础,一个模板就是一个创建类或函数的公式,当使用模板类型时,编译器会生成特定的类或函数,这个过程发生在编译时。 模板定义 模板定义以关键字template开始,后跟以个模板参数列表,这是一...
  • jQuery模板文件

    2020-04-29 16:37:52
    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>jquery</title> </head> <body> <!--JS库,比JS有趣...
  • java 根据模板文件生成word文档

    万次阅读 多人点赞 2018-09-19 16:18:05
    最近需要做一个导出word的功能, 在网上搜了下, 有用POI,JXL,iText等jar生成一个word文件然后将数据写到该文件中,API非常繁琐而且拼出来的样式也不美观,于是选择了另一种方式----feemarker基于word模板的导出方式, ...
  • 项目总结

    2020-07-29 16:41:10
    前端VUE VUE的MVVM模式: Model:负责数据存储–script View:负责页面展示–template标签 View Model:负责业务逻辑处理(比如Ajax请求等),对数据进行加工后交给视图展示–script @表示当前工程的src目录下 ...
  • String appId = ""//小程序appId String appSecret = "" //小程序秘钥 String url = ...secret="+appSecret+"&grant_type=client_credential" RestTemplate...
  • 十套精美个人博客网站模板

    万次阅读 多人点赞 2019-06-13 16:44:39
    紫色的图片博客个人页面模板 红色的微博社交平台HTML模板 响应式生活博客设计网站HTML5模板 程序员个人博客模板 响应式的互联网IT技术博客网站模板 仿17素材官网静态页面模板 Bootstrap生活类型博客网站模板 ...
  • IntelliJ IDEA设置类注释和方法注释模板

    万次阅读 多人点赞 2018-06-03 15:53:21
    IntelliJ IDEA设置类...然后选中自己的模板组,在模板组下新建模板如下图给模板设置信息1、设置模板名称,建议不要换,就是 * 号2、模板描述,可以没有3、模板,注意开头是没有 /* 的* *功能描述 * @author qqg...
  • 接口模板 接口文档

    万次阅读 2016-05-20 17:00:39
    接口文档 接口模板
  • 基于vue的前端模板(开源)

    万次阅读 热门讨论 2019-09-17 16:57:11
    效果不错哦 https://panjiachen.gitee.io/vue-element-admin/#/dashboard
  • 超详细设置Idea类注释模板和方法注释模板

    万次阅读 多人点赞 2017-12-11 17:36:39
    网上找了一下,没有很详细且正确介绍Idea配置注释模板的,于是结合多篇文章自己琢磨整理出如下。设置类注释模板1.选择File–>Settings–>Editor–>File and Code Templates–>Includes–>File Header. 2.在右边空白...
  • 5收集一些后台模板html_css

    万次阅读 热门讨论 2009-06-17 14:56:00
    准备想在框架的基础上写一个后台模板生成类,就好像之前用的那个框架一样.因为后台的样式基本上都是一样的,不需要什么特殊或者不规则的html,一些form,input,列表,分页,tab…不外乎就那么几种,完全没有必要花时间在...
1 2 3 4 5 ... 20
收藏数 1,440,557
精华内容 576,222
关键字:

模板