模板_模板匹配 - 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的,希望给大家有所帮助,别像...
  • 十一个精美的网站模板,一般够用,欢迎下载
  • 模板(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();
        }
    }
    
    展开全文
  • C/C++模板

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

    一.函数模板
    在一个int 型数组中,查找最大的数…
    在一个double 型数组中,查找最大的数…
    在一个float 型数组中,查找最大的数…
    在一个Objext[] 型数组中,查找最大的数…

    算法都是一样的:遍历数组,找出最大的数,只是元素的类型不一样而已

    如果每一种类型都重载一个函数,那么就太麻烦了。

    模板:template 定义一个模子,自动适应各个类型。

    语法:template
    T findmax(T arr[],int len)
    {
    T val = arr[0];

    }

    算法相同,元素类型不同,用T替代

    使用时,用<>来具体制指定typename的类型

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    template <typename T>
    T findmax(T arr[],int len)
    {
    	T val = arr[0];
    	for(int i = 0;i<len;i++)
    	{
    		if(arr[i] > val)
    		{
    			val = arr[i];
    		}
    	}
    	return val;
    }
    
    int main()
    {
    	int arr[4] = {1,5,7,80};
    	int result1 = findmax <int>(arr,4);
    	//在使用函数名为findmax<int>时,表示把int类型带入模板
    	printf("MAX = %d\n",result1);
    	
    	double abc[3] = {1.0,5.1,6.2};
    	double result2 = findmax<double>(abc,3);
    	printf("MAX = %.1f\n",result2);
    	
    	return 0;
    } 
    
    

    二.模板相关问题
    1.区分模板参数和函数参数
    模板参数:template<typename _T1,typename _T2>
    通常是一个类型的名字:int ,double, float.

    2.模板的语法检查
    例如自己定义一个类别,可能无法直接用 < >等符号直接比较,需要重载操作符

    3.模板通常定义在头文件里

    4.模板参数可以是多个

    三.类模板
    背景:

    需求:
    写一个各边长度的数组类Array
    用于存放各种元素,个数未知
    设计:
    内部动态申请一个buffer
    capacity:表示buffer的大小
    size:表示buffer已经存放元素的个数
    接口:
    Size():
    Capacity():最大容量
    Clear():清空,使size为0,capacity不变
    PushBack():添加一个元素。

    问题:这个类只适用于double类型,如果要存放int,char,以致任何类型呢?

    函数原型:

    #include <stdio.h>
    #include <string.h>
    
     用于存放double类型的对象
    class Array
    {
    public:
    	Array(int capacity=4)
    	{
    		m_buffer = new double[capacity];
    		m_capacity = capacity;
    		m_size = 0;
    	}
    
    	void PushBack(double val)
    	{
    		if(m_size >= m_capacity)
    		{
    			Resize();
    		}
    		m_buffer[m_size] = val;
    		m_size ++;
    	}
    	int Capacity()
    	{
    		return m_capacity;
    	}
    	int Size()
    	{
    		return m_size;
    	}
    
    private:
    	void Resize()
    	{
    		 创建一个更大的缓冲区
    		int n = m_capacity + 4;
    		double* buf = new double[n];
    
    		 拷贝原有的内容
    		memcpy(buf, m_buffer, m_capacity * sizeof(double));
    
    		 删除旧的内容,释放其内存
    		delete [] m_buffer;
    
    		 更新一下成员变量
    		m_capacity = n;
    		m_buffer = buf;
    	}
    
    private:
    	double* m_buffer;
    	int m_capacity; // 容量
    	int m_size; // 已经存放的对象的个数
    };
    
    int main()
    {
    	Array a; // 长度可变的数组
    	a.PushBack(1);
    	a.PushBack(2);
    	a.PushBack(3);
    	a.PushBack(4);
    	a.PushBack(5);
    
    	int size = a.Size();
    
    	return 0;
    }
    
    

    改变成类模板:

    //Array.h
    #ifndef _ARRAY_H
    #define _ARRAY_H
    
    // 用于存放double类型的对象
    template <typename _TT>
    class Array
    {
    public:
    	Array(int capacity=4)
    	{
    		m_buffer = new _TT[capacity];
    		m_capacity = capacity;
    		m_size = 0;
    	}
    
    	void PushBack(_TT val)
    	{
    		if(m_size >= m_capacity)
    		{
    			Resize();
    		}
    		m_buffer[m_size] = val;
    		m_size ++;
    	}
    	int Capacity()
    	{
    		return m_capacity;
    	}
    	int Size()
    	{
    		return m_size;
    	}
    
    private:
    	void Resize()
    	{
    		// 创建一个更大的缓冲区
    		int n = m_capacity + 4;
    		_TT* buf = new _TT[n];
    
    		// 拷贝原有的内容
    		memcpy(buf, m_buffer, m_capacity * sizeof(_TT) );
    
    		// 删除旧的内容,释放其内存
    		delete [] m_buffer;
    
    		// 更新一下成员变量
    		m_capacity = n;
    		m_buffer = buf;
    	}
    
    private:
    	_TT* m_buffer;
    	int m_capacity; // 容量
    	int m_size; // 已经存放的对象的个数
    };
    
    
    #endif
    
    
    
    //main.cpp
    #include <stdio.h>
    #include <string.h>
    
    #include "Array.h"
    
    int main()
    {
    	Array<int> a; // 长度可变的数组
    	a.PushBack(1);
    	a.PushBack(2);
    	a.PushBack(3);
    	a.PushBack(4);
    	a.PushBack(5);
    
    	int size = a.Size();
    
    	Array<float> b;
    	b.PushBack(2.3f);
    
    	return 0;
    }
    
    
    
    
    展开全文
  • 几款前端开源模板

    万次阅读 2020-10-22 13:23:08
    做前端,直接开开源模板不仅省很多工夫,而且还比较美观,所以收藏一些,以备查用。 1、AdminLTE AdminLTE是一个完全响应的后台管理模板。基于Bootstrap3框架。高度可定制,易于使用。适合许多屏幕分辨率从小型移动...

    做前端,直接开开源模板不仅省很多工夫,而且还比较美观,所以收藏一些,以备查用。

    1、AdminLTE

    AdminLTE是一个完全响应的后台管理模板。基于Bootstrap3框架。高度可定制,易于使用。适合许多屏幕分辨率从小型移动设备到大型台式机。
    在这里插入图片描述源码地址:https://github.com/ColorlibHQ/AdminLTE
    演示地址:https://adminlte.io/themes/AdminLTE/index2.html

    2、Gentelella Admin

    Gentelella Admin是一个免费的使用Bootstrap后台管理模板。该模板使用默认的Bootstrap3风格与各种强大的jQuery插件和工具来创建管理面板或后端仪表板创建一个强大的框架。
    在这里插入图片描述
    源码地址:https://github.com/ColorlibHQ/gentelella
    演示地址:https://colorlib.com/polygon/gentelella/index.html

    3、Vali Admin

    Gentelella Admin是一个免费的使用Bootstrap后台管理模板。该模板使用默认的Bootstrap3风格与各种强大的jQuery插件和工具来创建管理面板或后端仪表板创建一个强大的框架。
    在这里插入图片描述源码地址:https://github.com/pratikborsadiya/vali-admin
    演示地址:http://pratikborsadiya.in/vali-admin/

    4、ModularAdmin

    ModularAdmin是建立在一个模块化的方式,一个开放源码的仪表板的主题。这使得它非常容易扩展、修改和维护。
    在这里插入图片描述源码地址:https://github.com/modularcode/modular-admin-html
    演示地址:https://gurayyarar.github.io/AdminBSBMaterialDesign/index.html

    5、Metis

    METIS是一个简单但功能强大的免费自助管理仪表板的模板,你可以随意使用任何应用程序。
    在这里插入图片描述源码地址:https://github.com/puikinsh/Bootstrap-Admin-Template
    演示地址:https://colorlib.com/polygon/metis/

    6、Ace

    Ace是一个基于Twitter bootstrap3开发的后台模板。
    在这里插入图片描述源码地址:https://github.com/bopoda/ace
    演示地址:http://ace.jeka.by/

    7、Light Bootstrap Dashboard

    Light Bootstrap Dashboard是一个建立在Bootstrap3之上的、完全响应的管理仪表板模板设计,美丽而简单。Light Bootstrap Dashboard附带了大量的元素集合,可以为你提供最适合你需要的应用程序的多种可能性。它可以用来创建管理面板、项目管理系统、Web应用程序后端、CMS或CRM。
    在这里插入图片描述源码地址:https://github.com/creativetimofficial/light-bootstrap-dashboard
    演示地址:http://demos.creative-tim.com/light-bootstrap-dashboard

    8、Material Dashboard

    Material Dashboard是一个免费的 Material Bootstrap 后台。新的设计灵感来自谷歌的Material设计。Material Dashboard附带了一些第三方插件重新设计,以适应其余的元素
    在这里插入图片描述源码地址:https://github.com/creativetimofficial/material-dashboard
    演示地址:http://demos.creative-tim.com/material-dashboard/examples/dashboard.html

    9、Clearmin

    Clearmin是基于Bootstrap3开发的仪表板/程序/管理模板。
    在这里插入图片描述源码地址:https://github.com/paomedia/clearmin
    演示地址:http://cm.paomedia.com/

    10、SB-Admin-2

    在这里插入图片描述
    源码地址:https://github.com/BlackrockDigital/startbootstrap-sb-admin-2
    演示地址:https://startbootstrap.com/themes/sb-admin-2/



    参考:

    【1】、https://blog.csdn.net/H12KJGJ/article/details/79681432?utm_source=copyhttps://www.163.com

    【2】、https://mp.weixin.qq.com/s/jNGoi88nvBDMgH4qSMBiuA

    展开全文
  • 这是project常用模板的集合,包括企业信息化项目群,视频保安系统项目,项目变更案例(变更后),项目变更案例(变更前),项目计划变更记录,项目群案例,优化类项目计划模板,邮件系统合并项目,全是.mpp格式的...
  • 初学SolidWorks,可以联系我2847760392。学sw初期少走弯路,快速进步很重要。爱上设计,爱上创造!
  • 模板模板

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

    千次阅读 2019-09-07 20:05:40
    你好, 首先麻烦确定一下你在VS installer 里面成功安装了 相对应的工作负载 : .NET development workload. 关闭你的杀毒软件,使用devenv /safemode 启动VS: ...
  • 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目录下 ...
  • HTML5模板文件

    2020-04-29 16:42:24
    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> <!--引入css依赖及代码-->...link rel="stylesheet" href="/resourc...
  • 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.在右边空白...
1 2 3 4 5 ... 20
收藏数 1,439,203
精华内容 575,681
关键字:

模板