精华内容
下载资源
问答
  • 环境: VS2017 + pcl1.8.1 报错内容: 不可识别模板声明/定义 解决方法: 点击此错误后,会打开一个

    环境:
    VS2017 + pcl1.8.1
    报错内容:
    不可识别的模板声明/定义
    在这里插入图片描述
    解决方法:
    点击此错误后,会打开一个新的.c文件,将里面的这几行代码注释即可

    在这里插入图片描述

    展开全文
  • 错误 2 error C2988: 不可识别模板声明/定义 e:\exercise of programming\datastructrue+cpp\test_empty\test_empty\test.cpp 53 1 TEST_empty 错误 6 error C2447: “{”: 缺少函数标题(是否是老式的形式表?) e:\...
  • 1>c:\users\asus\desktop\huffman编码\huffman编码\huffman.h(14): error C2988: 不可识别模板声明/定义 1>c:\users\asus\desktop\huffman编码\huffman编码\huffman.h(14): error C2143: 语法错误: 缺少“;”(在...
  • template <class T> using is_arith_t = typename std::enable_if<std::is_arithmetic<T>::value>::type;
  • 为了解决生物识别系统因样本类内差异引起的识别性能下降,定义了用于评估模板价值的可代表性和不可替代性概念,并提出了基于认证信息最大化和不可替代权重最大化两种模板自动选择方法。在不同生物特征数据库中进行了...
  • 意图识别(规则模板解析、深度学习意图识别

    万次阅读 多人点赞 2019-09-12 12:33:54
    一、意图识别应用领域 1、搜索引擎 2、对话系统:基于意图识别了解用户想要什么 业务 或者 闲聊,并采用不用的子模型来处理 1.1 闲聊 技术:闲聊机器人需要有较高的召回率,因此常常用:seq2seq + attention / ...

     一、意图识别应用领域

    1、搜索引擎
    2、对话系统:基于意图识别了解用户想要什么 业务 或者 闲聊,并采用不用的子模型来处理
        1.1 闲聊
                技术:闲聊机器人需要有较高的召回率,因此常常用:seq2seq + attention  / transformer / bert .... 
        1.2 基于业务,例如 电商、买票、查询天气
                技术:基于上述应用场景需要极高的精确率,因此常常用:① 基于业务规则模板、基于语义匹配 ② 
    3、智能物联网
    4、机器人

    二、意图识别的难点

    1、用户输入不规范,输入方式多样化,甚至非标准的自然语言
    2、表意表现出多意图
           仙剑奇侠传
           游戏?--> 游戏软件?……
           电视剧?--> 电视剧下载?相关新闻?……
    3、意图强度,表述不同表现出不同的需求强度
           天气很好啊-->弱意图(心情,闲聊模式)          今天天气怎么样-->强意图(业务模式)
    4、意图存在时效性变化,就是随着时间的推移相同问题的意图会发生变化      ******* 难点
    5、没有固定的评估的标准
    

    三、意图识别的主要方法

       1、意图识别的类别

    (1)导航型 
           将用户导航到相应的领域或相应的流程中
                例:百度 *** 导入到某个网站
    (2)信息型 
           提供给用户想知道的信息
                例:百度 *** 的个人信息    ----- 类似百度百科
    (3)事务型 
           给用户提供流程中的各个实现环节
                例:百度 *** 坏了         ----- 类似百度知道
    

       2、规则模板意图识别

         (1)词表穷举法

                         特点:必须一一命中才行,因此模型的召回率较低,精确率极高 

       (2)规则模板解析    

                    规则模板解析: 需要基于  分词、词性标注、命名实体识别、依存句法分析、语义分析 的前提下 才能完成

                                               而且数据中使用的也是字典形式(key hash 结构),查询速度较快。

    1、适用于查询非常符合规则的类别,通过规则解析的方式来获取查询的意图。
        例:
            北京到上海今天的机票价格,可以转换为:[地点]到[地点][日期][汽车票/机票/火车票]。
                执行过程:
                        第一步:寻找领域,获取子类模板字典
                        第二步:选取模板,这里面命中模板不是所有的内容都全部命中,只需要命中一部分。
                        第三步:采取 反问模板 与用户沟通缺失了模板的那些内容,并补全这些内容(即上述问句没有日期)
                        第四步:给出 完整的模板信息 并 等待用户确认。
            1吨等于多少公斤,可以转换为:[数字][计量单位]等于[数字][计量单位]。
        对规则性较强的query有较好的识别精度,能够较好的提取准确信息。
        缺点:需要人工参与较多,很难自动化实现。
        实用指数:4★
        场景:搜狗通用搜索、小i智能客服、机器人、智能物联网、支付宝分控系统有10000多个模板。
    

                     特点:规则性较强的query精确率较高,召回率也不错 

    •    案例:搜狗搜索 意图识别

                         规则意图识别的一般技术

                                1. 判断领域:采用实体-主域-模板的整体框架来判别识别领域

                                          注意:主题    ------ 大类别 ;主域  ------- 子类别 ; 模板

                                2. 判断意图:命中主域后,模板采用意图动词(下载、查询等)或意图疑问词(怎么样、为什么等)判别意图

                                3. 区分弱意图和强意图,针对性提供解决方案;判断实体强度

                                    搜索引擎意图识别领域判别表:仙剑奇侠传

                     计算过程 

                              第一步:主体(大类)计算

                              第二步:主域(子类)计算 

    •  规则模板解析优化 
    4.  query改写包括:query纠错,query扩展,query删除,query转换。
             a. 进行同义词扩展     eg:我去旅游   我要旅游       ------- 技术:① word2vec ② 
             b. 删除一些修饰,扩大召回                          ------- 技术:① booststriping信息抽取 ② 语义分析(三元组)
             c. 通过近义或同义转化,扩大召回                    ------- 技术:① word2vec ② 
    

        3、深度学习意图识别

    1、机器学习和深度学习方法
        意图识别可以看做是一个分类问题,针对于垂直产品的特点,定义不同的查询意图类别。
        对于用户输入的query,根据统计分类模型计算出每一个意图的概率,最终给出查询的意图。             
        缺点:主要是数据获取和更新较困难,数据的标注也需要较准确才能训练出较好地模型。
        实用指数:4★
        场景:京东JIMI、美团垂直搜索
    
    2、深度学习 意图识别常见 模型:
        ① LSTM + attention
        ② BERT网络 分类意图识别

                       特点:模型召回率很高 

    •     案例:京东JIMI  意图识别

                          一、 大致结构

                       二、模型网络

    京东JIMI意图识别(baseline)
        深度学习CNN模型,可用于求解一个分类问题,将用户的问题映射到一个具体的分类。最终在算法选型上,采用深度学
        习CNN模型,其中模型参数:
            词向量采用100维
            每个样本限定30个字以内,超出30截断,不足30补充随机向量
            单层CNN网络,第一层卷积核大小3*50
    

     

     

    展开全文
  • C++声明定义、类的定义、头文件作用、头文件重复引用,具名空间 转自:http://www.cnblogs.com/rocketfan/archive/2009/10/02/1577361.html  首先说我的补充:(对声明定义的深入理解和总结) 关于声明和...

    C++声明、定义、类的定义、头文件作用、头文件重复引用,不具名空间

    转自:http://www.cnblogs.com/rocketfan/archive/2009/10/02/1577361.html  

    首先说我的补充:(对声明和定义的深入理解和总结)

    关于声明和定义,具体指类、函数和变量(或对象)的声明和定义。(这里讨论的变量和函数都是全局的,不是类成员)

    相同点:对编译器来说都是符号(编译器也只能识别他是个符合),声明就会在符合表中留下一列等待填充的空白,即不完整的等待填充一行,而定义就是符合表中完整的一行。在编译cpp成obj时,这里面变量、函数和类三种东西看成并列地位,即都是一个名字,符号表中的一列(可以先简单认为obj的符号表中只有两列即符号名字和地址)

    不同点,在使用上这三种符合的声明和定义有所区分:【定义类和变量是原子性,定义类不是原子性,还要用这个类去定义别的东西】

    (1)对于变量,由于变量的定义和声明是同一语句如int a; 所以规定声明必须使用extern关键字以区别是声明而不是定义。

    (2)对于函数,由于定义有个大括号包住的函数体,而声明没有大括号的函数体,所以它的声明和定义不需要多余的如extern关键字,即带大括号的是定义,不带的是声明。

    (3)对与类,在形式上和函数一样,名子带上大括号就是定义(定义一个类型),不带大括号的是声明。但他有特殊之处,即不能先声明类(即不带大括号),然后定义这个声明的类的实例,再在后面或在其它cpp文件中定义具体的类,而变量和函数是可以先声明然后在链接的时候从其它文件中找的。

    类之所以不能这样干,是因为,定义一个东西的干的事情主要就是为这个东西分配具体大小的内存,如果先声明一个类,然后定义这个类的实例,编译时(还没链接),就无法确定给这个实例到底分配多大的内存空间。变量和函数可以这样干是因为不需要再定义这两个东西的实例,即他们两个本事就是原子性的实体了,不需要用他们去创建一个原子实体。从上面分析可以看出,只要不涉及分配内存的事情,都可以先声明类,然后使用类,定义类在后面或在其它cpp文件中,实际上类的声明主要用在先声明,然后定义这个声明好的类的指针或引用(这个两个东西实体一般都固定分配4个字节)。关于类的声明和定义参见:http://blog.csdn.net/abc78400123/article/details/7599466

     正是因为类的这个方面的特殊性,所以规定类的定义可以在多个cpp中,编译器不检查这中冲突(不得不这样做),而变量和函数是不行的(有的书上说类定义不占内存空间而函数和变量定义占内存空间,我认为这中说法不太好,实际上类和函数都在代码区也占内存空间,变量在数据区)。使用时也是把类定义在一个头文件中,在不同的cpp中展开,即完成了在不同的cpp中定义同一个类。我进一步猜测,也正因为这样,类定义体中不能像c#或java那样直接包含成员变量的定义并初始化,实际上类定义体中的所有东西都被认为是声明(要不然的话定义类的同时就会定义一堆其它的东西,就乱了,类体的作用就是为了描述定义这个类的实例时要分配多大的内存空间),即使函数实现在了类体中也被默认是inline内联的函数(对外不导出,也就是说其它cpp中看不见)。当然如果都用inline浪费空间,所以常常把函数声明写在类体中(达到描述这个类的作用就行了),而把成员函数具体定义(包括函数体)放在和这个类定义的头文件对应的cpp文件中,这也是为什么c++在定义类的时候分头文件和cpp文件,甚至有的书上说头文件中是类的声明,cpp文件中是类的实现(当然这种说法我也不很认同,他没分清是类的定义还是类体中东西的定义,严格的说头文件是类体中所有东东都必然是声明,cpp中是所有类体中东东的实现,类的实现完全可以不要,完全可以把函数全部称为inline的,完全可以把成员变量在构造函数被调用的时候分配内存并填充数据。类的定义就是类名加上大括号,所以类的定义都在头文件中,cpp才是这个类定义所在的头文件的附属,因为完全可以不要cpp而把函数实现都写成inline的)。

    也正是因为类的这个方面的特殊性,类定义(类名加上大括号)中的所要成员变量都不能直接初始化,因为他们被认为是声明(虽然没有extern),只起描述这个类的作用。对于类中的静态成员变量和常量成员变量也是先声明,然后在cpp中定义静态变量和常变量并初始化(这里要注意声明static和const的变量不用初始化,而定义这两个东西的时候必须同时初始化,引用和他们两个类似)

     说了这么多,有点绕,简单点可以认为,类定义体中(即大括号中)包含的全部是其它实体的描述,不能定义类的同时定义了其它的东西(个别少见情况除外,但不违背这里描述的原理),在使用类的成员时,再根据这个描述去其它obj中找到对应的实体。而包含在类体中的成员就看成是个描述(或就是个头衔名),这个描述具体定义在外部,只不过定义在外部的成员的名字都加上了一个姓:类名。从编译器和连接器的角度来看,这个头衔名包含在类体中的姓类名的成员函数(或变量)和全局的函数(或变量)没什么区别,都是函数(或变量)。而类定义体中也不是定义了新的东西,他只不过包含了在其它地方定义好了的东西的描述或引用头衔而已。总之类定义就是描述作用(这个描述就是给new关键字看的),描述这个类的实例将占多大内存,将具有什么功能而已。类体中并没有定义新的东西,类体也是个外包,包含了在其它地方定义好了的东西的描述。

     

     

    下面是原网页的内容: 

    1.  编译单元,一个.cc,或.cpp作为一个编译单元.生成.o

    2.  普通数据类型的定义,声明,函数的定义声明(类函数是一样的)

    • extern int x; //变量是声明,并未实际分配地址,未产生实际目标代码

          void print(); // 函数声明,  未产生实际目标代码

          如int x; int x = 3 ; void print() {}; //均为定义产生了实际目标代码

    • 声明不产生实际的目标代码,它的作用是告诉编译器,OK,我在该编译单元后面,或者其它编译单元会有这个x变量,print函数的定义。否则编译器如果发现程序用到x,print,而前面没有声明会报错。如果有声明,而没有定义,那么链接的时候会报错未定义。
    • 比较常见的是我在source.cc中调用print(),而head.h中声明print(),而source.cc 中include

           head.h从而就有了print的声明,可以通过编译,但是如果在所有编译单元中没有print函数的定义,那么链 

           接的时候source.o单元就会出错,因为它试图用print函数但是找不到print的定义。

            //head.h

           void pirnt();

           //source.cc

           void foo() {

                print();

           }

    • 由于声明不产生实际代码,所以可以有多个重复声明的存在。

           //source1.cc

           extern int x;

           //source2.cc

           extern int x;

          甚至同一个编译单元也可以有多各个重复声明

          //source1.cc

          extern int x;

          extern int x;

          而普通变量定义,函数定义是不允许的。

    3. 同一编译单元内部的重名符号在编译期就被阻止了,而不同编译单元之间的重名符号要到链接器才会被发

         现。 

         如果你在一个 source1.cc中

         //source1.cc

         int x;

         int x;

         出现两次 int x; int x;即两个x的定义,会编译报错,x重复定义。

         如果你的

         //source1.cc

         int x;

         //source2.cc

         int x;

         g++ –o test source1.cc source2.cc

         那么编译过程不会出错,在链接过程,由于目标代码中有两个全局域的x,会链接出错,x重定义。

         不同的编程人员可能会写不同的模块,那么很容易出现这种情况,如何避免呢,namespace可以避免重名。

         google 编程规范鼓励使用不具名空间

         //source1.cc

         namespace {

         int x;

         }

         //source2.cc

         namespace {

         int x;

         }

         OK,现在不会链接出错了因为两个x不重名了,当然对于这个简单的例子只在source1.cc中用不具名命名空间就可

         避免链接出差了。

      //注

         //source1.cc

         namespace {

         int x;

         }

        //source1.cc

        static int x;

       有什么区别呢,看上去效果一样,区别在于不具名空间的x仍然具有外链接,但是由于它是不具名的,所以别的单元没办法链接到,如果

       namespace haha{

       int x;

       }  

       则在别的单元可以用haha::x访问到它,static 则因为是内部链接特性,所以无法链接到。

    记得以前一个同事问我为什么程序里使用了 anonymouse namespace ,想了想 就回答说其实就是保持局部性(这也是我的目的),然后就有人说为什么不用static,嗯 似乎这两个东西乍一看没什么区别,自己便Google了一下,发现有一个原因就是 anonymousenamespace 里的 member 都是有外部链接的,只不过永远都不能被外部link到!而 static 就明确为根本没有外部链接!此时就出现问题了,在模板里无类型的参数必须是有外部链接的才可以,否则编译无法通;比如:
    template <void fn()>
    class Foobar
    {};

    namespace
    {
    void abc()
    {
    wcout<<_T(”abc”)<<endl;
    };
    }
    static void efg()
    {
    wcout<<_T(”efg”)<<endl;
    };
    int _tmain(int argc, _TCHAR* argv[])
    {
    Foobar<abc>xyz //! ;这一行可以通过
    Foobar<efg>rst; //! 注意这一行编译不过
    return 0;
    }
    也有人认为使用 anon namespace比较好,因为static的方式被C++98标准所批评,呵呵 总体来说 ,其实你完全可以用anony namespace代替static

    4.  关于头文件。

         //head.h

         int x;

         //source1.cc

         #include “head.h”

         //source2.cc

         #include “head.h” 

         头文件不被编译,.cc中的引用 include “ head.h”其实就是在预编译的时候将head.h中的内容插入到.cc中。

         所以上面的例子如果

             g++ –o test source1.cc source2.cc, 同样会链时发现重复定义的全局变量x。

         因此变量定义,包括函数的定义不要写到头文件中,因为头文件很可能要被多个.cc引用。

         那么如果我的head.h如下这么写呢,是否防止了x的链接时重定义出错呢?

         //head.h

         #ifndef _HEAD_H_

         #define _HEAD_H_

         int x;

         #endif

         //source1.cc

         #include “head.h”

         //source2.cc

         #include “head.h” 

            现在是否g++ –o test source1.cc source2.cc就没有问题了呢,答案是否定的。

          所有的头文件都是应该如上加#ifndef    #endif的,但它的作用是防止头文件在同一编译单元被重复引用。

          就是说防止可能的

         //source1.cc

         #include “head.h”

         #include “head.h”

         这种情况,当然我们不会主动写成上面的形式但是,下面的情况很可能发送

         //source1.cc

         #include “head.h”

         #inlcude “a.h”

         //a.h

         #include “head.h”

         这样就在不经意见产生了同一编译单元的头文件重复引用,于是soruc1.cc 就出现了两个int x;定义。

         但是对于不同的编译单元source1.cc,source2.cc他们都是还会引用head.h的,即使#ifndef #endif的存在。

    5. 关于类的声明和定义。

        class A;  //类的声明

        类的声明和普通变量声明一样,不产生目标代码,可以在同一,以及多个编译单元重复声明。

       class A {

       };  //类的定义

       类的定义就特殊一点了,可能会有疑问,为什么不能把int x;这样的变量定义放到.h中(见4)但是可以把  

       类的定义放在头文件中重复引用呢?同时类的函数非inline定义(写在类定义里面的函数是inline,除外)不能写在 

      头文件中呢。

      这是因为类的定义,只是告诉编译器,类的数据格式是如何的,实例话后对象该占多大空间。

      类的定义也不产生目标代码。因此它和普通变量的声明唯一的区别是不能在同一编译单元内出现多次。

      //source1.cc

       class A;

       class A;  //类重复声明,OK

       class A{

       };

       class A{

       };       

       class A{

           int x;

      };    //同一编译单元内,类重复定义,会编译时报错,因为编译器不知道在该编译单元,A a;的话要生产怎样的a.

             //如果class A{};定义在head.h ,而head.h 没有 

             //#ifndef  #endif 就很可能在同一编译单元出现类重复定义的编译错误情况。

     

    但是在不同编译单元内,类可以重复定义,因为类的定义未产生实际代码。

      //source1.cc

      class A{

      }

      //source2.cc

      class A{

      }                      //不同编译单元,类重复定义,OK。所以类的定义可以写在头文件中!

                                    

          //source1.cc

          class A{

         

          }

          //source2.cc

          class A{

              int x;

          }                      //不同编译单元,OK

     

       6. 总结

           1.在头文件中写变量的声明,函数声明,类的定义,inline函数,不要出现变量定义,类的函数非inline定义,函数定

             义。

             即在头文件中不要出现可能产生目标代码的东东。

           2.为了防止在一个编译单元内部头文件重复引用,所有头文件都要加上#ifndef   #endif

           3.鼓励在.cc中使用不具名namespace,可以有效防止不同编译单元命名冲突。

           4.相关更专业详细的介绍可以看<<大规模C++程序设计>>的第一章,会有极其好的完整介绍。

              其中提到类的定义是具有内部链接特性的,即它不是声明

              不能在同一编译单元重复出现,但是它具有内部链接,(所谓内部链接指的是该名称对于所在编译单元是局部的,在链接时不会与其他编译单元中同样 

                的名称产生命名冲突),所以类如果要在单个编译单元之外使用它必须被定义在一个头文件中

              对于声明和定义,书中给出的定义是:

             一个声明将一个名称引入程序,一个定义提供了一个实体(例如,类型,实例,函数)在一个程序中的唯一描述。

            5. 前面第一条说的不是很确切,按照<<大规模C++程序设计>>中的说法

                理论上头文件中可以放所有具有内部链接的东西,包括具有内部链接的定义。如

                static int x;

                static void print() {};

                但是不提倡这么做,因为每一个包含这个头文件的.cc就对应要开辟一个空间存储这个x,就是说不同编译单元都引入static int x;由于是内部链接,所以互不影响彼此。

               甚至你采用namespace也是如此,如

               在.h中

               namespace myspace {

                    static int x;

               }

               不同.cc文件中都引入该头文件,在各自编译单元中调用的myspace::x也是不同的互不影响的!

                书中提到

                const int width = 3;  //见书的23页

                这样的const变量也要避免出现在头文件中,不过类似以前c语言中

                在头文件中

                #define width  3

                还是很常用的啊。难道也要在

                .h中

                extern const int width;

                .cc中

                 const int width = 5;

                 这样虽然可以,不过好麻烦啊,我倒觉得在.h中定义类似const int width =3 问题不大,难道编译器不会做些特殊的处理优化吗,也要每个单元分配一个单独空间?

                 不过倒是也可以利用下面的方法在.h中声明一批const 变量。注意和普通static 变量不同,类的成员静态变量,静态函数是具有外部链接的。如果

    static const  int  SUCCESS = 0; ,SUCCESS不是 const 仅仅是 static int,那么是不可以在类内初始化的(编译出错),需要在某个.cc文件中初始话,因为它是具有外部链接的。(在GOOGLE编程规范中,提到禁止使用类类型的全局变量,静态成员变量视为全局变量,也禁止使用类类型)

        class code   

        {

    public:

       static const result_code SUCCESS = 0;//program ended successfully

       static const result_code INVALID_ADDRESS = 1;//wrong addres

       static const result_code READ_FAIL = 2;//cannot read

       static const result_code WRITE_FAIL = 3;//cannot write

       static const result_code UNKNOWN_ACTION = 4;//dunno...

       static const result_code NOT_FOUND = 5;//key not found in paragraph

       static const result_code NO_WRITE = 6;//no write since modification

       static const result_code SYNTAX_ERR = 7;//command syntax error

       static const result_code EMPTY_CLIP = 8;//the clipboard is empty

        };

     

     

     

     

     

     

    下面是C++编译链接过程

    转自:http://blog.csdn.net/changyang208/article/details/8642288

    GCC的编译过程

    总体来说,C/C++源代码要经过:预处理编译汇编链接,四步才能变成相应平台下的可执行文件。

    File: hw.c

     

    [cpp]  view plain copy
    1. #include <stdio.h>  
    2.   
    3. int main(int argc, char *argv[])  
    4. {  
    5.   printf("Hello World!\n");  
    6.   return 0;  
    7. }  

    如果用gcc编译,只需要一个命令就可以生成可执行文件hw:

    gcc -o hw.exe  hw.c

    接下来我们按照编译顺序看看编译器每一步都做了什么:

    cpp hw.c -o hw.i  // 预处理 gcc -E hello.c -o hello.i

    cc1 hw.i -o hw.s    // 编译 gcc -S hello.i -o hello.s 

    as hw.s -o hw.o     // 汇编 gcc -c hello.s -o hello.o

    ld hw.o -o hw.exe   // 链接 gcc hello.o -o hello.exe


    第一步,预处理,主要处理以下指令:宏定义指令,条件编译指令,头文件包含指令。 预处理所完成的基本上是对源程序的“替代”工作。经过此种替代,生成一个没有宏定义、没有条件编译指令,头文件都被展开(递归展开)的文件。

    第二步,编译,就是把C/C++代码“翻译”成汇编代码。

    第三步,汇编,就是将生成的汇编代码翻译成符合一定格式的机器代码,在Linux上一般表现为ELF目标文件。

    第四步,链接,将生成的目标文件和系统库文件进行链接,最终生成了可以在特定平台运行的可执行文件。为什么还要链接系统库中的某些目标文件(crt1.o, crti.o等)呢?这些目标文件都是用来初始化或者回收C运行时环境的,比如说堆内存分配上下文环境的初始化等,实际上crt也正是C RunTime的缩写。这也暗示了另外一点:程序并不是从main函数开始执行的,而是从crt中的某个入口开始的,在Linux上此入口是_start。而且默认情况下,ld是将这些系统库文件(本身也是动态库)都是以动态链接方式加入应用程序的,如果要以静态连接的方式进行,需要显示的指定ld命令的参数-static

    此外,还有一个优化阶段。优化处理是编译系统中一项比较艰深的技术。它涉及到的问题不仅同编译技术本身有关,而且同机器的硬件环境也有很大的关系。优化一部分是对中间代码的优化。 这种优化不依赖于具体的计算机。另一种优化则主要针对目标代码的生成而进行的。对于前一种优化,主要的工作是删除公共表达式、循环优化(代码外提、强度削弱、变换循环控制条件、已知量的合并等)、复写传播,以及无用赋值的删除,等等。 后 一种类型的优化同机器的硬件结构密切相关,最主要的是考虑是如何充分利用机器的各个硬件寄存器存放的有关变量的值,以减少对于内存的访问次数。另外,如何 根据机器硬件执行指令的特点(如流水线、RISC、CISC、VLIW等)而对指令进行一些调整使目标代码比较短,执行的效率比较高。

    目标文件的三个表:未解决符号表,导出符号表和地址重定向表

    1、编译:编译器对源文件进行编译,就是把源文件中以文本形式存在的源代码翻译成机器语言形式的目标文件的过程,在这个过程中,编译器会进行一系列的语法检查。如果编译通过,就会把对应的CPP转换成OBJ文件。

    2、目标文件:由编译所生成的文件,以机器码的形式包含了编译单元里所有的代码和数据,还有一些其它信息,如未解决符号表,导出符号表和地址重定向表等。目标文件是以二进制的形式存在的。

    目标文件由段组成。通常一个目标文件中至少有两个段: 
    代码段:该段中所包含的主要是指令,该段一般是可读和可执行的,但一般却不可写。 
    数据段:主要存放程序中要用到的各种全局变量或静态数据。一般数据段都是可读,可写,可执行的。 

          根据C++标准,一个编译单元(Translation Unit)是指一个.cpp文件以及它所include的所有.h文件,.h文件里面的代码将会被扩展到.cpp文件里,然后编译器编译该.cpp文件生成一个.obj文件。当编译器将一个工程里的所有.cpp文件都编译完毕后,再由链接器进行链接,成为一个.exe或库文件。

    下面让我们来分析一下编译器的工作过程,假设我们有一个A.cpp文件,如下定义:

        int n =1;

        void FunA()

        {

           ++n;

        }

       它编译出来的目标文件A.obj就会有一个区域(或者说是段),包含以上的数据和函数,其中就有n、FunA,以文件偏移量形式给出可能就是下面这种情况:

       偏移量   内容    长度

       0x0000         4

       0x0004   FunA    ??

       注意:这只是说明,与实际目标文件的布局可能不一样,??表示长度未知,目标文件的各个数据可能不是连续的,也不一定是从0x0000开始。

       FunA的内容可能如下:

        0x0004 inc DWORD PTR[0x0000]

        0x00?? ret

       有另外一个B.cpp文件,定义如下:

        externint n;

        voidFunB()

        {

           ++n;

        }

       它对应的B.obj的二进制应该是:

       偏移量   内容    长度

       0x0000   FunB    ??

       这里为什么没有n的空间呢,因为n被声明为extern,这个extern关键字就是告诉编译器n已经在别的编译单元里定义了,在这个单元里就不要定义了。由于编译单元之间是互不相关的,所以编译器就不知道n究竟在哪里,所以在函数FunB就没有办法生成n的地址,那么函数FunB中就是这样的:

        0x0000 inc DWORD PTR[????]

        0x00?? ret

       解析????的工作就只能由链接器来完成了。为了能让链接器知道哪些地方的地址没有填好(????),目标文件中有一个表来告诉链接器,这个表就是“未解决符号表”,也就是unresolved symbol table。同样,提供n的目标文件也要提供一个“导出符号表”,也就是exprot symbol table,来告诉链接器自己可以提供哪些地址。

       到这里我们已经知道,一个目标文件不仅要提供数据和二进制代码,还至少要提供两个表:未解决符号表和导出符号表,来告诉链接器自己需要什么和自己能提供些什么。那么这两个表是怎么建立对应关系的呢?这里就有一个新的概念:符号。在C/C++中,每一个变量及函数都会有自己的符号,如变量n的符号就是n,函数的符号会更加复杂,假设FunA的符号就是_FunA(根据编译器不同而不同)。

       A.obj的导出符号表为

       符号      地址

          n       0x0000

     _FunA   0x0004

       未解决符号为空(因为他没有引用别的编译单元里的东西)。

       B.obj的导出符号表为

       符号    地址

    _FunB   0x0000

       未解决符号表为

       符号    地址

              0x0001

       这个表告诉链接器,在本编译单元0x0001位置有一个地址,该地址不明,但符号是n。

       在链接的时候,链接在B.obj中发现了未解决符号,就会在所有的编译单元中的导出符号表去查找与这个未解决符号相匹配的符号名,如果找到,就把这个符号的地址填到B.obj的未解决符号的地址处。如果没有找到,就会报链接错误。在此例中,在A.obj中会找到符号n,就会把n的地址填到B.obj的0x0001处。

       但是,这里还会有一个问题,如果是这样的话,B.obj的函数FunB的内容就会变成inc DWORDPTR[0x000](因为n在A.obj中的地址是0x0000)。由于每个编译单元的地址都是从0x0000开始,那么最终多个目标文件链接时就会导致地址重复。所以链接器在链接时就会对每个目标文件的地址进行调整。在本例中,假如B.obj的0x0000被定位到可执行文件的0x00001000上,而A.obj的0x0000被定位到可执行文件的0x00002000上,那么实现上对链接器来说,A.obj的导出符号地地址都会加上0x00002000,B.obj所有的符号地址也会加上0x00001000。这样就可以保证地址不会重复。

       既然n的地址会加上0x00002000,那么FunA中的inc DWORDPTR[0x0000]就是错误的,所以目标文件还要提供一个表,叫地址重定向表,address redirect table

       总结一下:

       目标文件至少要提供三个表:未解决符号表,导出符号表和地址重定向表。

       未解决符号表:列出了本单元里有引用但是不在本单元定义的符号及其出现的地址。

       导出符号表:提供了本编译单元具有定义,并且可以提供给其他编译单元使用的符号及其在本单元中的地址。

       地址重定向表:提供了本编译单元所有对自身地址的引用记录。

    链接器的工作顺序:

       当链接器进行链接的时候,首先决定各个目标文件在最终可执行文件里的位置。然后访问所有目标文件的地址重定义表,对其中记录的地址进行重定向(加上一个偏移量,即该编译单元在可执行文件上的起始地址)。然后遍历所有目标文件的未解决符号表,并且在所有的导出符号表里查找匹配的符号,并在未解决符号表中所记录的位置上填写实现地址。最后把所有的目标文件的内容写在各自的位置上,就生成一个可执行文件。

       实际链接的时候会更加复杂,目标文件都会把数据,代码分成好几个区,重定向是按区进行,但原理都是一样的。

    重温C/C++中的特性:

       extern:这就是告诉编译器,这个变量或函数在别的编译单元里定义了,也就是要把这个符号放到未解决符号表里面去。

       static:如果static位于全局函数或者全局变量的声明前面,表明该编译单元不导出这个函数或变量,因此这个符号不能在别的编译单元中使用。

    默认链接属性:对于函数和变量,默认链接是外部链接,对于const变量,默认内部链接。

    外部链接的利弊:外部链接的符号在整个程序范围内都是可以使用的,这就要求其他编译单元不能导出相同的符号(不然就会报duplicated external symbols)。

    内部链接的利弊:内部链接的符号不能在别的编译单元中使用。但不同的编译单元可以拥有同样的名称的符号。

     为什么常量默认为内部链接,而变量不是?

            这就是为了能够在头文件里如const int n = 0这样的定义常量。由于常量是只读的,因此即使每个编译单元都拥有一份定义也没有关系。如果一个定义于头文件里的变量拥有内部链接,那么如果出现多个编译单元都定义该变量,则其中一个编译单元对该变量进行修改,不会影响其他单元的同一变量,会产生意想不到的后果。

    为什么头文件里一般只可以有声明不能有定义?

        头文件可以被多个编译单元包含,如果头文件里面有定义的话,那么每个包含这头文件的编译单元都会对同一个符号进行定义,如果该符号为外部链接,则会导致duplicatedexternal symbols链接错误。因此如果头文件里要定义,必须保证定义的符号只能具有内部链接。

    为什么类的静态成员变量不可以就地初始化?

        由于class的声明通常是在头文件里,如果允许这样做,其实就相当于在头文件里定义了一个非const变量。 

    头文件里内联函数被拒绝会怎样?

        如果定义于头文件里的内联函数被拒绝,那么编译器会自动在每个包含了该头文件的编译单元里定义这个函数,并且不导出符号。

    如果被拒绝的内联函数里定义了静态局部变量,这个变量会被定义于何处?

         早期的编译器会在每个编译单元里定义一个,并因此产生错误的结果,较新的编译器会解决这个问题,手段未知。

    在C++环境下使用C函数的时候,常常会出现编译器无法找到C函数定义,从而导致链接失败的情况,应该如何解决这种情况呢?
      C++语言在编译的时候为了解决函数的多态问题,会将函数名和参数联合起来生成一个中间的函数名称,而C语言则不会,因此会造成链接时找不到对应函数的情况,此时C函数就需要用extern “C”进行链接指定,这告诉编译器,请保持我的名称,不要给我生成用于链接的中间函数名。例如,假设某个函数的原型为:
      void foo( int x, int y );
      该函数被C编译器编译后在符号表中的名字为_foo,而C++编译器则会产生像_foo_int_int之类的名字(不同的编译器可能生成的名字不同,但是都采用了相同的机制,生成的新名字称为“mangled name”)。
      _foo_int_int这样的名字包含了函数名、函数参数数量及类型信息,C++就是靠这种机制来实现函数重载的。

    展开全文
  • 一、类模板定义及实例化 1. 定义一个类模板: 1 templateclass 模板参数表> 2 3 class 类名{ 4 5 // 类定义...... 6 7 };   其中,template 是声明类模板的关键字,表示声明一个模板,模板...
     
    

    在C++发明阶段,C++之父Stroustrup和贝尔实验室的C++小组对原先的宏方法进行了修订,对其进行了简化并将它从预处理范围移入了编译器。这种新的代码替换装置被称为模板,而且它变现了完全不同的代码重用方法:模板对源代码重用,而不是通过继承和组合重用对象代码。当用户使用模板时,参数由编译器来替换,这非常像原来的宏方法,却更清晰,更容易使用。

    模板使类和函数可在编译时定义所需处理和返回的数据类型,一个模板并非一个实实在在的类或函数,仅仅是一个类和函数的描述。由于模板可以实现逻辑相同、数据类型不同的程序代码复制,所以使用模板机制可以减轻编程和维护的工作量和难度。模板一般分为模板函数和类模板。以所处理的数据类型的说明作为参数的类就叫类模板,或者模板类,而以所处理的数据类型的说明作为参数的函数,则称为函数模板。

    本文包含函数目标和类模板,有些可能会交错设计两个模块的细节。

    1.函数模板

    函数模板定义了参数化的非成员函数,这使得程序员能够用不同类型的参数调用相同的函数,由编译器决定调用哪一种类型,并且从模板中生成相应的代码。

    定义:

    Template﹤类型参数表﹥返回类型 函数名 (形参表){函数体}

    简单实例,调用函数打印字符串或数字等。

    普通函数形式:

     
    1. #include <string> 
    2. #include <iostream> 
    3. void printstring(const std::string& str)  
    4. {     
    5.     std::cout << str << std::endl; 
    6. int main() 
    7. {     
    8.     std::string str("Hello World");     
    9.     printstring(str); 
    10.     return 0; 
    11. }//输出:Hello World 

    模板函数形式:

     
    1. #include <string> 
    2. #include <iostream> 
    3. using namespace std; 
    4. template<typename T> void print(const T& var) 
    5. {     
    6.     cout << var << endl; 
    7. int main() 
    8. {     
    9.     string str("Hello World");     
    10.     const int num=1234; 
    11.     print(str); 
    12.     print(num); 
    13.     return 0; 
    14. //输出:Hello World  
    15. //       1234 

    可以看出使用模板后的函数不仅可以输出字符串形式还可以输出数字形式的内容。

    上面两个例子介绍了函数模板的简单使用方法,但只有一个参数,如果需要多个参数,相应的函数模板应采用以下形式定义:

    Template﹤类型1 变量1,类型2 变量2 ,…﹥返回类型 函数名 (形参表){函数体}

    现在,为了看到模板时如何称为函数的,我们假定min()函数接受各种类型的参数,并找出其中的最小者,如果不采用模板技术,则只能接受一个特定类型的参数,如果希望也能接受其他类型的参数,就需要对每一种类型的参数都定义一个同功能的函数,其实为函数的重载,这里不在讨论,但这将是一件非常让人麻烦的事情。如:

    普通定义:

     
    1. #include <iostream.h> 
    2. // 定义多态函数,找出三个整数中最小的数 
    3. int min0(int ii, int jj, int kk) 
    4.     int temp; 
    5.     if((ii<jj)&&(ii<kk)){temp=ii;} 
    6.     else if((jj<ii)&&(jj<kk)){temp=jj;    } 
    7.     else{    temp=kk;    } 
    8.     return temp; 
    9. // 定义多态函数,找出三个小数中最小的数 
    10. float min1(float ii, float jj, float kk) 
    11.     float temp; 
    12.     if((ii<jj)&&(ii<kk)){temp=ii;} 
    13.     else if((jj<ii)&&(jj<kk)){temp=jj;    } 
    14.     else{    temp=kk;    } 
    15.     return temp; 
    16.   
    17. // 定义多态函数,找出三个子符中最小的字符 
    18. char min2(char ii, char jj, char kk) 
    19.     char temp; 
    20.     if((ii<jj)&&(ii<kk))    {temp=ii;    } 
    21.     else if((jj<ii)&&(jj<kk)){temp=jj;}     
    22.     else{temp=kk;} 
    23.     return temp; 
    24.   
    25. void main() 
    26.     int temp1=min0(100,20,30); 
    27.     cout<<temp1<<endl; 
    28.     float temp2=min1(10.60,10.64,53.21); 
    29.     cout<<temp2<<endl; 
    30.     char temp3=min2('c','a','C'); 
    31.     cout<<temp3<<endl; 
    32. //以换行形式输出20  10.6  C 

    使用模板:

     
    1. #include <iostream.h> 
    2. // 定义函数模板,找出三个值中最小的值,与数据类型无关 
    3. template <class T> 
    4. T min(T ii, T jj, T kk) 
    5.     T temp; 
    6.     if((ii<jj)&&(ii<kk)){temp=ii;} 
    7.     else if((jj<ii)&&(jj<kk)){temp=jj;} 
    8.     else{    temp=kk; } 
    9.     return temp; 
    10. // 下面是主函数 
    11. void main() 
    12.     cout<<min(100,20,30)<<endl; 
    13.     cout<<min(10.60,10.64,53.21)<<endl; 
    14.     cout<<min('c','a','C')<<endl; 

    输出结果同上,但可以清楚的看到二者之间的工作量大小之差距。

    函数模板功能非常强大,但是有时候可能会陷入困境,加入待比较的函数模板没有提供正确的操作符,则程序不会对此进行编译。为了避免这种错误,可以使用函数模板和同名的非模板函数重载,这就是函数定制。函数模板与同名的非模板函数重载必须遵守以下规定:

    寻找一个参数完全匹配的函数,如有,则调用它

    如果失败,寻找一个函数模板,使其实例化,产生一个匹配的模板函数,若有,则调用它

    如果失败,再试低一级的对函数重载的方法,例如通过类型转换可产生的参数匹配等,若找到匹配的函数,调用它

    如果失败,则证明这是一个错误的调用

    现在用上例的模板函数比较两个字符串,但会出现问题:

     
    1. #include <iostream.h> 
    2. // 定义函数模板,找出三个值中最小的值,与数据类型无关 
    3. template <class T> 
    4. T min(T ii, T jj, T kk) 
    5.     T temp; 
    6.     if((ii<jj)&&(ii<kk)){     temp=ii; } 
    7.     else if((jj<ii)&&(jj<kk)){ temp=jj; } 
    8.     else{    temp=kk;} 
    9.     return temp; 
    10. void main()  
    11.     cout<<min("anderson","Washington","Smith")<<endl; 

    输出anderson 与实际结果不否,原因在于编译器会生成对字符串指针做比较的函数,但比较字符串和比较字符串指针是不一样的,为了解决此问题,我们可以定制函数模板,如:

     
    1. #include <iostream> 
    2. #include <string> 
    3. using namespace std; 
    4. // 定义函数模板,找出三个值中最小的值,与数据类型无关 
    5. template <class T> 
    6. T min(T ii, T jj, T kk) 
    7.     T temp; 
    8.     if((ii<jj)&&(ii<kk)){        temp=ii;    } 
    9.     else if((jj<ii)&&(jj<kk)){        temp=jj;    } 
    10.     else    {        temp=kk;    } 
    11.     return temp; 
    12. //非模板函数重载 
    13. const char* min(const char* ch1, const char* ch2,const char* ch3) 
    14.     const char* temp; 
    15.     int result1 = strcmp(ch1,ch2); 
    16.     int result2 = strcmp(ch1,ch3); 
    17.     int result3 = strcmp(ch2,ch1); 
    18.     int result4 = strcmp(ch2,ch3); 
    19.     if((result1<0)&&(result2<0))    {        temp = ch1;    } 
    20.     else if((result3<0)&&(result4<0))    {        temp=ch2;    } 
    21.     else    {        temp=ch3;    } 
    22.     return temp; 
    23. void main() 
    24.     cout<<min(100,20,30)<<endl; 
    25.     cout<<min(10.60,10.64,53.21)<<endl; 
    26.     cout<<min('c','a','C')<<endl;     
    27.     cout<<min("anderson","Washington","Smith")<<endl; 

    在VS 2010中,最后一行会输出Smith, 与结果先符。

    注意:若上例在VC++ 6.0 中运行,其结果最后一行仍会输出anderson,读者可自己上机查看情况并分析原因。

    下面给出一些实例:

     
    1. #ifndef HEADER_MY 
    2. #define HEADER_MY 
    3. #include <string> 
    4. #include <sstream> 
    5. template<class T> 
    6. T fromString(const std::string &s) 
    7.     std::istringstream is(s); 
    8.     T t; 
    9.     is>>t; 
    10.     return t; 
    11. template<class T> 
    12. std::string toString(const T &s) 
    13.     std::ostringstream t; 
    14.     t<<s; 
    15.     return t.str(); 
    16.   
    17. #endif 
    18.   
    19.   
    20. #include "HEADER.h"  
    21. #include <iostream>  
    22. #include <complex>  
    23. using namespace std;  
    24. int main()  
    25. {  
    26.     int i = 1234;  
    27.     cout << "i == \"" << toString(i) << "\"\n";  
    28.     float x = 567.89;  
    29.     cout << "x == \"" << toString(x) << "\"\n";  
    30.     complex<float> c(1.0, 2.0);  
    31.     cout << "c == \"" << toString(c) << "\"\n";  
    32.     cout << endl;  
    33.     i = fromString<int>(string("1234"));  
    34.     cout << "i == " << i << endl;  
    35.     x = fromString<float>(string("567.89"));  
    36.     cout << "x == " << x << endl;  
    37.     c = fromString< complex<float> >(string("(1.0,2.0)"));  
    38.     cout << "c == " << c << endl;  
    39.     return 0; 

    模板实参推演

    当函数模板被调用时,对函数实参类型的检查决定了模板实参的类型和值的这个过程叫做模板实参推演。如template <class T> void h(T a){}; h(1); h(0.2);第一个调用因为实参是int型的,所以模板形参T被推演为int型,第二个T的类型则为double。

    在使用函数模板时,请注意以下几点:

    在模板被实例化后,就会生成一个新的实例,这个新生成的实例不存在类型转换。比如有函数模板template <class T>void H(T a){};int a=2; short b=3;第一个调用H(a)生成一个int型的实例版本,但是当调用h(b)的时候不会使用上次生成的int实例把short转换为int,而是会另外生成一个新的short型的实例。

    在模板实参推演的过程中有时类型并不会完全匹配,这时编译器允许以下几种实参到模板形参的转换,这些转换不会生成新的实例。

    数组到指针的转换或函数到指针的转换:比如template<class T> void h(T * a){},int b[3]={1,2,3};h(b);这时数组b和类型T *不是完全匹配,但允许从数组到指针的转换因此数组b被转换成int *,而类型形参T被转换成int,也就是说函数体中的T被替换成int。

    限制修饰符转换:即把const或volatile限定符加到指针上。比如template<class T> void h(const T* a){},int b=3; h(&b);虽然实参&b与形参const T*不完全匹配,但因为允许限制修饰符的转换,结果就把&b转换成const int *。而类形型参T被转换成int。如果模板形参是非const类型,则无论实参是const类型还是非const类型调用都不会产生新的实例。

    到一个基类的转换(该基类根据一个类模板实例化而来):比如tessmplate<class T1>class A{}; template<class T1> class B:public A<T1>{}; template<class T2> void h(A<T2>& m){},在main函数中有B<int> n; h(n);函数调用的子类对象n与函数的形参A<T2>不完全匹配,但允许到一个基类的转换。在这里转换的顺序为,首先把子类对象n转换为基类对象A<int>,然后再用A<int>去匹配函数的形参A<T2>&,所以最后T2被转换为int,也就是说函数体中的T将被替换为int。

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

    模板实参推演实例,说明内容较长,采用注释形式,但代码较乱:

     
    1. #include <iostream> 
    2. using namespace std; 
    3. template<class T>void h(T a){cout<<" h()"<<typeid(T).name()<<endl;}  //带有一个类型形参T的模板函数的定义方法,typeid(变量名).name()为测试变量类型的语句。 
    4. template<class T>void k(T a,T b){T c;cout<<" k()"<<typeid(T).name()<<endl;} //注意语句T c。模板类型形参T可以用来声明变量,作为函数的反回类型,函数形参等凡是类类型能使用的地方。 
    5. template<class T1,class T2> void f(T1 a, T2 b){cout<<" f()"<<typeid(T1).name()<<","<<typeid(T2).name()<<endl;}   //定义带有两个类型形参T1,T2的模板函数的方法template<class T> void g(const T* a){T b;cout<<" g()"<<typeid(b).name()<<endl;}  
    6. //template<class T1,class T2=int> void g(){}  //错误,默认模板类型形参不能用于函数模板,只能用于类模板上。 
    7. //main函数开始 
    8. int main() 
    9. // template<class T>void h(){} //错误,模板的声明或定义只能在全局,命名空间或类范围内进行。即不能在局部范围,函数内进行。 
    10. //函数模板实参推演示例。 
    11. // h(int); //错误,对于函数模板而言不存在h(int,int)这样的调用,不能在函数调用的参数中指定模板形参的类型,对函数模板的调用应使用实参推演来进行,即只能进行h(2,3)这样的调用,或者int a, b; h(a,b)。 
    12. //h函数形式为:template<class T>void h(T a) 
    13. h(2);//输出" h() int"使用函数模板推演,在这里数值2为int型,所以把类型形参T推演为int型。 
    14. h(2.0);//输出" h() double",因为2.0为double型,所以将函数模板的类型形参推演为double型 
    15. //k函数形式为:template<class T>void k(T a,T b) 
    16. k(2,3);//输出" k() int" 
    17. //k(2,3.0);错误,模板形参T的类型不明确,因为k()函数第一个参数类型为int,第二个为double型,两个形参类型不一致。 
    18. //f函数的形式为:template<class T1,class T2> void f(T1 a, T2 b) 
    19. f(3,4.0);//输出" f() int,double",这里不存在模板形参推演错误的问题,因为模板函数有两个类型形参T1和T2。在这里将T1推演为int,将T2推演为double。 
    20. int a=3;double b=4; 
    21. f(a,b); //输出同上,这里用变量名实现推板实参的推演。 
    22. //模板函数推演允许的转换示例,g函数的形式为template<class T> void g(const T* a) 
    23. int a1[2]={1,2};g(a1); //输出" g() int",数组的地址和形参const T*不完全匹配,所以将a1的地址T &转换为const T*,而a1是int型的,所以最后T推演为int。 
    24. g(&b); //输出" g() double",这里和上面的一样,只是把类型T转换为double型。 
    25. h(&b); //输出" h() double *"这里把模参类型T推演为double *类型。 
    26. return 0; 

    函数模板的显示实例化

    隐式实例化:比如有模板函数template<class T> void h(T a){}。h(2)这时h函数的调用就是隐式实例化,既参数T的类型是隐式确定的。

    函数模板显示实例化声明:其语法是:template  函数反回类型 函数名<实例化的类型> (函数形参表); 注意这是声明语句,要以分号结束。例如:template  void h<int> (int a);这样就创建了一个h函数的int 实例。再如有模板函数template<class T> T h( T a){},注意这里h函数的反回类型为T,显示实例化的方法为template int h<int>(int a); 把h模板函数实例化为int 型。

    对于给定的函数模板实例,显示实例化声明在一个文件中只能出现一次。

    在显示实例化声明所在的文件中,函数模板的定义必须给出,如果定义不可见,就会发生错误。

    注意:不能在局部范围类显示实例化模板,实例化模板应放在全局范围内,即不能在main函数等局部范围中实例化模板。因为模板的声明或定义不能在局部范围或函数内进行。

    显示模板实参:

    1、显示模板实参:适用于函数模板,即在调用函数时显示指定要调用的时参的类型。

    2、格式:显示模板实参的格式为在调用模板函数的时候在函数名后用<>尖括号括住要显示表示的类型,比如有模板函数template<class T> void h(T a, T b){}。则h<double>(2, 3.2)就把模板形参T显示实例化为double类型。

    3、显示模板实参用于同一个模板形参的类型不一致的情况。比如template<class T> void h(T a, T b){},则h(2, 3.2)的调用会出错,因为两个实参类型不一致,第一个为int 型,第二个为double型。而用h<double>(2, 3.2)就是正确的,虽然两个模板形参的类型不一致但这里把模板形参显示实例化为double类型,这样的话就允许进行标准的隐式类型转换,即这里把第一个int 参数转换为double类型的参数。

    4、显示模板实参用法二:用于函数模板的反回类型中。例如有模板函数template<class T1, class T2, class T3> T1 h(T2 a, T3 b){},则语句int a=h(2,3)或h(2,4)就会出现模板形参T1无法推导的情况。而语句int h(2,3)也会出错。用显示模板实参就参轻松解决这个问题,比如h<int, int, int>(2,3)即把模板形参T1实例化为int 型,T2和T3也实例化为int 型。

    5、显示模板实参用法三:应用于模板函数的参数中没有出现模板形参的情况。比如template<class  T>void h(){}如果在main函数中直接调用h函数如h()就会出现无法推演类型形参T的类型的错误,这时用显示模板实参就不会出现这种错误,调用方法为h<int>(),把h函数的模板形参实例化为int 型,从而避免这种错误。

    6、显示模板实参用法四:用于函数模板的非类型形参。比如template<class T,int a> void h(T b){},而调用h(3)将出错,因为这个调用无法为非类型形参推演出正确的参数。这时正确调用这个函数模板的方法为h<int, 3>(4),首先把函数模板的类型形参T推演为int 型,然后把函数模板的非类型形参int a用数值3来推演,把变量a设置为3,然后再把4传递给函数的形参b,把b设置为4。注意,因为int a是非类型形参,所以调用非类型形参的实参应是编译时常量表达式,不然就会出错。

    7、在使用显示模板实参时,我们只能省略掉尾部的实参。比如template<class T1, class T2, class T3> T1 h(T2 a, T3 b){}在显示实例化时h<int>(3, 3.4)省略了最后两个模板实参T2和T3,T2和T3由调用时的实参3和3.4隐式确定为int 型和double型,而T1被显示确定为int 型。h<int, , double><2,3.4>是错误的,只能省略尾部的实参。

    8、显示模板实参最好用在存在二义性或模板实参推演不能进行的情况下。

    下面来看看实例:

     
    1. #include <iostream> 
    2. using namespace std; 
    3. template<class T>void g1(T a, T b){cout<<"hansu g1()"<<typeid(T).name()<<endl;} 
    4. template<class T1,class T2,class T3>T1 g2(T2 a,T3 b) 
    5. {T1 c=a;cout<<"hansug2()"<<typeid(T1).name()<<typeid(T2).name()<<typeid(T3).name()<<endl; return c;} 
    6. template<class T1,class T2> void g3 ( T1 a ) {cout<<"hansu g3()"<<typeid(T1).name()<<typeid(T2).name()<<endl;} 
    7. template<class T1,int a> void g4(T1 b, double c){cout<<"hansu g4()"<<typeid(T1).name()<<typeid(a).name()<<endl;} 
    8. template<class T1,class T2> class A{public:void g();}; 
    9. //模板显示实例化示例。 
    10. //因为模板的声明或定义不能在局部范围或函数内进行。所以模板实例化都应在全局范围内进行。 
    11. template void g1<double>(double a,double b); //把函数模板显示实例化为int型。 
    12. template class A<double,double>; //显示实例化类模板,注意后面没有对象名,也没有{}大括号。 
    13. //template class A<int,int>{};  //错误,显示实例化类模板后面不能有大括号{}。 
    14. //template class A<int,int> m;  //错误,显示实例化类模板后面不能有对象名。 
    15. //main函数开始 
    16. int main() 
    17. {//显示模板实参示例。显示模板实参适合于函数模板 
    18. //1、显示模板实参用于同一个模板形参的类型不一致的情况。函数g1形式为template<class T>void g1(T a, T b) 
    19. g1<double>(2,3.2);//输出"hansu g1() int"两个实参类型不一致,第一个为int第二个为double。但这里用显示模板实参把类型形参T指定为double,所以第一个int型的实参数值2被转换为double类型。 
    20. //g1(2,3.2);错误,这里没有用显式模板实参。所以两个实参类型不一致。 
    21. //2、用于函数模板的反回类型中。函数g2形式为template<class T1,class T2,class T3> T1 g2(T2 a,T3 b) 
    22. //g2(2,3);错误,无法推演类型形参T1。 
    23. //int g2(2,3);错误,不能以这种方法试图推导类型形参T1为int型。 
    24. //int a=g2(2,3);错误,以这种方式试图推演出T1的类型为int也是错误的。 
    25. g2<int,int,int>(2,3);//正确,将T1,T2,T3 显示指定为int型。输出"hansu g2() intintint" 
    26. //3、应用于模板函数的参数中没有出现模板形参的情况其中包括省略的用法,函数g3的形式为template<class T1,class T2> void g3(T1 a) 
    27. //g3(2);错误,无法为函数模板的类型形参T2推演出正确的类型 
    28. //g3(2,3);错误,岂图以这种方式为T2指定int型是错误的,因为函数只有一个参数。 
    29. //g3<,int>(2);错误,这里起图用数值2来推演出T1为int型,而省略掉第一个的显示模板实参,这种方法是错误的。在用显示模板实参时,只能省略掉尾部的实参。 
    30. //g3<int>(2);错误,虽然用了显示模板实参方法,省略掉了尾部的实参,但该方法只是把T1指定为int型,仍然无法为T2推演正确的类型。 
    31. g3<int,int>(2);//正确,显示指定T1和T2的类型都为int型。 
    32. //4、用于函数模板的非类型形参。g4函数的形式为template<class T1,int a> void g4(T1 b,double c) 
    33. //g4(3,3.2);错误,虽然指定了两个参数,但是这里仍然无法为函数模板的非类型形参int a推演出正确的实参。因为第二个函数参数x.2是传递给函数的参数double c的,而不是函数模板的非类型形参int a。 
    34. //g4(3,2);错误,起图以整型值把实参传递给函数模板的非类型形参是不行的,这里数值2会传递给函数形参double c并把int型转换为double型。所以非类型形参int a仍然无实参。 
    35. //int d=1; g4<int ,d >(3,3.2); //错误,调用方法正确,但对于非类型形参要求实参是一个常量表达式,而局部变量c是非常量表达式,不能做为非类型形参的实参,所以错误。 
    36. g4<int,1>(2,3.2);//正确,用显示模板实参,把函数模板的类型形参T1设为int型,把数值1传给非类型形参int a,并把a设为1,把数值2 传给函数的第一个形参T1 b并把b设为2,数值?.2传给函数的第二个形参double c并把c设为?.2。 
    37. const int d=1; g4<int,d>(2,3.2);//正确,这里变量d是const常量,能作为非类型形参的实参,这里参数的传递方法同上面的语句。 
    38. return 0; 

    显示具体化(模板特化,模板说明) 和函数模板的重载

    1、具体化或特化或模板说明指的是一个意思,就是把模板特殊化,比如有模板template<class T>void h(T a){},这个模板适用于所有类型,但是有些特殊类型不需要与这个模板相同的操作或者定义,比如int 型的h实现的功能和这个模板的功能不一样,这样的话我们就要重定义一个h模板函数的int 版本,即特化版本。

    特化函数模板:

    2、显示特化格式为:template<>  反回类型函数名<要特化的类型>(参数列表) {函数体},显示特化以template<>开头,表明要显示特化一个模板,在函数名后<>用尖括号括住要特化的类型版本。比如template <class T> void h(T a){},其int 类型的特化版本为template<> void h<int>(int a){},当出现int 类型的调用时就会调用这个特化版本,而不会调用通用的模板,比如h(2),就会调用int 类型的特化版本。

    3、如果可以从实参中推演出模板的形参,则可以省略掉显示模板实参的部分。比如:template<> void h(int a){}。注意函数h后面没有<>符号,即显示模板实参部分。

    4、对于反回类型为模板形参时,调用该函数的特化版本必须要用显示模板实参调用,如果不这样的话就会出现其中一个形参无法推演的情况。如template<class T1,class T2,class T3> T1 h(T2 a,T3 b){},有几种特化情况:

    情况一:template<> int h<int,int>(int a, in b){}该情况下把T1,T2,T3的类型推演为int 型。在主函数中的调用方式应为h<int>(2,3)。

    情况二:template<> int h(int a, int b){},这里把T2,T2推演为int 型,而T1为int 型,但在调用时必须用显示模板实参调用,且在<>尖括号内必须指定为int 型,不然就会调用到通用函数模板,如h<int>(2,3)就会调用函数模板的特化版本,而h(2,3)调用会出错。h<double>(2,3)调用则会调用到通用的函数模板版本。

    这几种情况的特化版本是错误的,如template<> T1 h(int a,int b){},这种情况下T1会成为不能识别的名字,因而出现错误,template<> int h<double>(int a,int b){}在这种情况下反回类型为int 型,把T1确定为int 而尖括号内又把T1确定为double型,这样就出现了冲突。

    5、具有相同名字和相同数量反回类型的非模板函数(即普通函数),也是函数模板特化的一种情况,这种情况将在后面参数匹配问题时讲解。

    函数模板重载(函数定制):

    1、函数模板可以重载,注意类模板不存在重载问题,也就是说出现这两条语句时template<class  T>class A{};

    template<classT1,class T2>class A{};将出错。

    2、模板函数重载的形式为:template<class T> void h(T a, int b){}。Template<class T>void h(T a, double b){}等。

    3、重载模板函数要注意二义性问题,比如template<class T> void h(T a, int b){}和template<class T>void h(T a, T b){}这两个版本就存在二义性问题,当出现语句h(2,3)时就不知道调用哪个才正确,在程序中应避免这种情况出现。

    4、重载函数模板的第二个二义性问题是template<class T>void h(T a, T b){}与template<class T1, class T2>void h(T1 a,T2 b){},当出现h(2,4)这样的调用时就会出现二义性。解决这个问题的方法是使用显示模板实参,比如要调用第一个h函数,可以使用语法h<int>(2,3),调用第二个h函数的方法为h<int, int>(2,3)。

    5、函数模板的特化也可以理解为函数模板重载的一种形式。只是特化以template<>开始。

    6、重载的特殊情况:比如template<class T1,class T2> void h(T1 a, T2 b){},还有个版本如template<class T1>void h(T1 a, int b){}这里两个函数具有两同的名字和相同的形参数量,但形参的类型不同,可以认为第二个版本是第一个版本的重载版本。

    7、函数模板的重载和特化很容易混晓,因为特化很像是一个函数的重载版本,只是开头以template<>开始而已。

    特化类模板

    6、特化整个类模板:比如有template<class T1,class T2> class A{};其特化形式为template<> class A<int, int>{};特化形式以template<>开始,这和模板函数的形式相同,在类名A后跟上要特化的类型。

    7、在类特化的外部定义成员的方法:比如template<class T> class A{public: void h();};类A特化为template<>  class A<int>{public: void h();};在类外定义特化的类的成员函数h的方法为:void A<int>::h(){}。在外部定义类特化的成员时应省略掉template<>。

    8、类的特化版本应与类模板版本有相同的成员定义,如果不相同的话那么当类特化的对象访问到类模板的成员时就会出错。因为当调用类的特化版本创建实例时创建的是特化版本的实例,不会创建类模板的实例,特化版本如果和类的模板版本的成员不一样就有可能出现这种错误。比如:模板类A中有成员函数h()和f(),而特化的类A中没有定义成员函数f(),这时如果有一个特化的类的对象访问到模板类中的函数f()时就会出错,因为在特化类的实例中找不到这个成员。

    9、类模板的部分特化:比如有类模板template<class T1, class T2> class A{};则部分特化的格式为template<class T1> class A<T1, int>{};将模板形参T2特化为int 型,T1保持不变。部分特化以template开始,在<>中的模板形参是不用特化的模板形参,在类名A后面跟上要特化的类型。如果要特化第一个模板形参T1,则格式为template<class T2> class A<int, T2>{};部分特化的另一用法是template<class T1> class A<T1,T1>{};将模板形参T2也特化为模板形参T1的类型。

    10、在类部分特化的外面定义类成员的方法:比如有部分特化类template<class T1> class A<T1,int>{public: void h();};则在类外定义的形式为template<class T1> void A<T1,int>::h(){}。注意当在类外面定义类的成员时template 后面的模板形参应与要定义的类的模板形参一样,这里就与部分特化的类A的一样template<class T1>。

    其他说明:

    11、可以对模板的特化版本只进行声明,而不定义。比如template<> void h<int>(int a);注意,声明时后面有个分号。

    12、在调用模板实例之前必须要先对特化的模板进行声明或定义。一个程序不允许同一模板实参集的同一模板既有显示特化又有实例化。比如有模板template<class T> void h(T a){}在h(2)之前没有声明该模板的int 型特化版本,而是在调用该模板后定义该模板的int 型特化版本,这时程序不会调用该模板的特化版本,而是调用该模板产生一个新的实例。这里就有一个问题,到底是调用由h(2)产生的实例版本呢还是调用程序中的特化版本。

    13、注意:因为模板的声明或定义不能在局部范围或函数内进行。所以特化类模板或函数模板都应在全局范围内进行。

    14、在特化版本中模板的类型形参是不可见的。比如template<> void h<int,int>(int a,int b){T1 a;}就会出现错误,在这里模板的类型形参T1在函数模板的特化版本中是不可见的,所以在这里T1是未知的标识符,是错误的。

     
    1. #include <iostream> 
    2. using namespace std; 
    3. //函数模板特化和类模板特化示例 
    4. //定义函数g1,g2和类A 
    5. template<class T1,class T2> void g1(T1 a,T2 b){cout<<"g1"<<endl;} 
    6. template<class T1,class T2,class T3>T1 g2(T2 a,T3 b){  int c=1;cout<<"g2"<<endl;return c;} 
    7. template<class T1,class T2,class T3>class A{public:void h();} 
    8. //函数模板的特化定义。函数模板的特化可以理解为函数模板重载的另一种形式。 
    9. //下式为g1的类型形参显示指定其类型,把T1,T2在模板实参的尖括号中设为int型。 
    10. template<> void g1<int,int>(int a,int b){cout<<"g1一"<<endl;} 
    11. //下式显示设定g1的类型形参T1,并设为int型,T2由函数参数double推演为double型。 
    12. template<> void g1<int>(int a,double b){cout<<"g1二"<<endl;}   
    13. template<> void g1(double a,double b){cout<<"g1三"<<endl;} //g1的类型形参都由g1的形参推演出来。 
    14. //template<> void g1<int>(double a,int b){cout<<"g•一"<<endl;}  //错误,在显示模板实参的尖括号中显示把类型形参T1的类型设为int型,而又在函数的形参中把类型形参T1的类型推演为double型,这样就发生了冲突,出现错误。 
    15. template<> int g2<int>(int a,int b){int c=1;cout<<"g2一"<<endl;return c;} 
    16.  template<>double g2(int a,int b){int c=1;cout<<"g2二"<<endl;return c;} 
    17. //注意,下式正确,该式并不是对函数模板g2的部分特化,而是g2的重载。 
    18. //template<class T2> int g2(int a, T2 b){int c=1;cout<<"g2三"<<endl;return c;} 
    19. //下式错误,函数反回类型和<double>尖括号中的double类型不同,发生冲突。 
    20. //template<> int g2<double>(int a,int b){int c=1;cout<<"two"<<endl;return c;}  
    21. //下式错误,函数模板的类型形参在特化版本中是不可见的,也就是说这里的会把类型形参T1理解为未声明的标识符 
    22. //template<> T1 g2<int>(int a,int b){int c=1;cout<<"two"<<endl;return c;}  
    23. //类模板的特化和部分特化 
    24.  template<>class A<int,int,int>{public:void h();}//特化整个类模板的格式,注意类名后的尖括号中必须指定所有的类模板的类型形参。 
    25. //template<> class A<int>{}; //错误,在特化的类名后的尖括号中指定的类模板类型形参的数量不够。要想只特化其中一个类模板的类型形参,就要使用类模板的部分特化。 
    26. template<class T1,class T3>class A<T1,double,T3>{public:void h();}//特化T2,而T1和T?不特化,注意尖括号中的类型形参是不特化的形参。 
    27. //在类模板的特化或部分特化版本的外部定义成员函数的方法。 
    28. void A<int,int,int>::h(){cout<<"class A tehua"<<endl;} /*  T1 c; 错误,在特化版本中模板的类型形参是不可见的,也就是说在这里 
    29. T1是未声明的标识符。*/ 
    30. //template<> void A<int,int,int>::h(){} //错误,在类模板的特化版本外面定义类模板的成员时应省略掉template<> 
    31. template<class T1,class T3>void A<T1,double,T3)::h(){cout<<"class A bute"<<endl;} 
    32. template<class T1,class T2,class T3>void A<T1,T2,T3>::h(){cout<<"class A putong"<<endl;} //定义普通类模板中的成员函数。 
    33. //main函数开始 
    34. int main() 
    35. {   //特化的函数模板的调用方式。 
    36.     g1(2,2); //输出"g1一",调用函数模板g1的第一个特化版本template<> void g1<int,int>(int a,int b){cout<<"g1一"<<endl;} 
    37.     g1(2,3.2); //输出"g1二",调用函数模板g1的第二个特化版本template<> void g1<int>(int a,double b){cout<<"g1二"<<endl;} 
    38.     g1(3.3,4.4); //输出"g1三",调用函数模板g1的第三个特化版本template<> void g1(double a,double b){cout<<"g1三"<<endl;} 
    39.     g1<double>(3,2.3);//输出"g1三",这里用显示模板实参把第一个实参指定为double型,这样g1的两个实参都是double型,所以将调用g1的第三个特化版本。 
    40.     //g2(3,3); 错误,在调用反回类型为类型形参的时候必须用显示模板实参的形式为反回类型的形参显示指定类型。在这里就会出现无法为T1确定类型的情况。 
    41.     g2<int>(2,3);//正确,把g2的类型形参T1设显示指定为int,调用g2的第一个特化版本。template<> int g2<int>(int a,int b){int c=1;cout<<"g2一"<<endl;return c;} 
    42.     g2<double>(2,3);//正确,把g2的类型形参T1设显示指定为double,调用g2的第二个特化版本。template<> double g2(int a,int b){int c=1;cout<<"g2二"<<endl;return c;} 
    43.     g2<char>(2,3);//正确,把g2的类型形参T1设显示指定为char,对于char版本的g2函数没有特化版本,因此调用g2的通用版本。 
    44.     //    template<class T1,class T2,class T3>T1 g2(T2 a,T3 b) {int c=1;cout<<"g2"<<endl;return c;} 
    45.    // 类模板特化和部分特化的调用。 
    46.      A<int,int,int> m1; m1.h();//正确,调用类模板的特化版本。 
    47.      A<int,double,int> m; m.h(); //正确,调用类模板的部分特化版本。 
    48.            //A<int,int> m2; //错误,类模板有三个类型形参,这里只提供了两个,数量不够,错误。 
    49.      A<double,double,int> m3; m3.h();//调用类A的部分特化版本。 
    50.       A<double,int,int> m4; m4.h();//调用类A的普通版本,在这里没有A<double,int,int>型的特化或者部分特化版本可用。 
    51.       return 0; 

    1. 类模板

    在此之前我们来看看模板的形参。因为函数模板的参数相对比较简单,故将此内容放置于类模板中。模板形参有三种类型:类型形参、非类型形参和模板形参。先分别解释如下:

    类型形参。即由关键字class 或 typename后接的说明符构成,如template <class T>void function(T a);其中T就是类型形参。类型形参的名字由用户自定义,只要是合法的标识符即可。

    非类型形参。模板的非类型形参也就是内置类型形参,如template<class T,int a>class B{};其中int a就是非类型形参。非类型形参在模板定义的内部是常量值,也就是说非类型形参在模板内部是常量。使用非类型形参应注意以下几点:

    非类型形参只能是整型、指针和应用。如:double,string,string **等都是不允许的,但是double & ,double *是正确的。

    调用非类型模板形参的实参必须是一个常量表达式,即在编译时就能确定其结果。任何局部对象、局部变量、局部变量地址、局部对象地址等都不是一个常量表达式,都不能用作非类型模板形参的实参。全局指针类型、全局变量、全局对象也不是一个常量表达式,不能用作非类型形参的实参。但全局变量的地址、全局对象的地址或应用const类型的变量时常量表达式,可用作非类型模板形参的实参。Sizeof表达式的结果也是一个常量表达式,同样也可以用作非类型模板形参的实参。如:

    Template <class T,int a>class A{};如果有int b,这时A<int,b> m;就会出错,因为b不是常量,如果有const int b;这时A<int ,b>就是正确的。

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

    非类型模板形参和实参间允许转换。具体如下;

    允许从数组到指针,从函数到指针的转换。如template <int *a>class A{};int b[1];A<b>m。

    Const修饰符的转换。如template <const int *a>class A{};int b;A<&b>m;即从int * 到const int *的转换。

    提升转换。如template <int a>class A{};const shor b;A<b>m;即从short到int的提升转换。

    整值转换。如template <unsigned int a> class A{};A<3> m;即从int到unsigned int的转换。

    可以为类模板的类型形参提供默认值,但不能为函数模板的类型形参提供默认值。函数模板和类模板都可以为模板的非类型形参提供默认值。如template <class T1,class T2=int>class A{};为第二个模板类型形参提供int型的默认值。

    类模板的类型形参默认值和函数的默认参数一样,如果有多个类型形参则从第一个设定了默认值之后所以的模板形参都应设定默认值。如template <class T1=int,class T2>class D{};就是错误的,因为没有给T2设定默认值。但在外部定义类中的成员时,应省去默认的形参类型。如template <class T1,class T2=int>class A{public:void H();};定义方法是template <class T1,class T2>void A<T1,T2>::H(){};

    现将以上小节总结于以下一例,并通过vs2010调试,请读者仔细相关知识点的应用。

     
    1. #include <iostream> 
    2. using namespace std; 
    3. //模板的声明或定义只能在全局,命名空间或类范围内进行。即不能在局部范围,函数内进行,比如不能在main函数中声明或定义一个模板。 
    4. //类模板的定义 
    5. template<class T>class A{public:T g(T a, T b); A();};  //定义带有一个类模板类型形参T的类A 
    6. template<class T1,class T2>class B{public:void g();}; //定义带有两个类模板类型形参T1,T2的类B 
    7. //定义类模板的默认类型形参,默认类型形参不适合于函数模板。 
    8. template<class T1,class T2=intclass D{publicvoid g();}; //定义带默认类型形参的类模板。这里把T2默认设置为int型。 
    9. //template<class T1=int, class T2>class E{}; //错误,为T1设了默认类型形参则T1后面的所有形参都必须设置认默值。 
    10. //以下为非类型形参的定义 
    11. //非类型形参只能是整型,指针和引用,像double,String, String **这样的类型是不允许的。但是double &,double *对象的引用或指针是正确的。 
    12. template<class T1,int a> class Ci{public:void g();}; //定义模板的非类型形参,形参为整型 
    13. template<class T1,int &a>class Cip{public:void g();};  
    14. template<class T1,A<int>* m> class Cc{public:void g();}; //定义模板的模板类型形参,形参为int型的类A的对象的指针。 
    15. template<class T1,double*a>class Cd{public:void g();};  //定义模板的非类型形参,形参为double类型的引用。 
    16. class E{}; template<class T1,E &m> class Ce{}; //非类型模板形参为对象的引用。 
    17. //以下非类型形参的声明是错误的。 
    18. //template<class T1,A m>class Cc{}; //错误,对象不能做为非类型形参,非类型模板形参的类型只能是对象的引用或指针。 
    19. //template<class T1,double a>class Cc{}; //错误,非类型模板的形参不能是double类型,可以是double的引用。 
    20. //template<class T1,A<int> m>class Cc{}; //错误,非类型模板的形参不能是对象,必须是对象的引用或指针。这条规则对于模板型参也不例外。 
    21. //在类模板外部定义各种类成员的方法, 
    22. //typeid(变量名).name()的作用是提取变量名的类型,如int a,则cout<<typeid(a).name()将输出int 
    23. template<class T>   A<T>::A(){cout<<"class A goucao"<<typeid(T).name()<<endl;} //在类模板外部定义类的构造函数的方法 
    24. template<class T> T A<T>::g(T a,T b){cout<<"class A g(T a,T b)"<<endl;} //在类模板外部定义类模板的成员 
    25. template<class T1,class T2>  void B<T1,T2>::g(){cout<<"class g f()"<<typeid(T1).name()<<typeid(T2).name()<<endl;} 
    26. //在类外面定义类的成员时template后面的模板形参应与要定义的类的模板形参一致 
    27. template<class T1,int a>     void Ci<T1,a>::g(){cout<<"class Ci g()"<<typeid(T1).name()<<endl;} 
    28. template<class T1,int &a>    void Cip<T1,a>::g(){cout<<"class Cip g()"<<typeid(T1).name()<<endl;}  
    29. //在类外部定义类的成员时,template后的模板形参应与要定义的类的模板形参一致 
    30. template<class T1,A<int> *m> void Cc<T1,m>::g(){cout<<"class Cc g()"<<typeid(T1).name()<<endl;} 
    31. template<class T1,double* a> void Cd<T1,a>::g(){cout<<"class Cd g()"<<typeid(T1).name()<<endl;} 
    32. //带有默认类型形参的模板类,在类的外部定义成员的方法。 
    33. //在类外部定义类的成员时,template的形参表中默认值应省略 
    34. template<class T1,class T2>  void D<T1,T2>::g(){cout<<"class D g()"<<endl;} 
    35. //template<class T1,class T2=int> void D<T1,T2>::g(){cout<<"class D k()"<<endl;} //错误,在类模板外部定义带有默认类型的形参时,在template的形参表中默认值应省略。 
    36. //定义一些全局变量。 
    37. int e=2;  double ed=2.2; double*pe=&ed; 
    38. A<int> mw; A<int> *pec=&mw; E me; 
    39. //main函数开始 
    40. int main() 
    41. // template<class T>void h(){} //错误,模板的声明或定义只能在全局,命名空间或类范围内进行。即不能在局部范围,函数内进行。 
    42.     //A<2> m; //错误,对类模板不存在实参推演问题,类模板必须在尖括号中明确指出其类型。 
    43.     //类模板调用实例 
    44.     A<int> ma; //输出"class A goucao int"创建int型的类模板A的对象ma。 
    45.     B<int,int> mb; mb.g(); //输出"class B g() int int"创建类模板B的对象mb,并把类型形参T1和T2设计为int 
    46.     //非类型形参的调用 
    47.     //调用非类型模板形参的实参必须是一个常量表达式,即他必须能在编译时计算出结果。任何局部对象,局部变量,局部对象的地址,局部 
    48. //    变量的地址都不是一个常量表达式,都不能用作非类型模板形参的实参。全局指针类型,全局变量,全局对象也不是一个常量表达式,不能 
    49. //        用作非类型模板形参的实参。 
    50.         //全局变量的地址或引用,全局对象的地址或引用const类型变量是常量表达式,可以用作非类型模板形参的实参。 
    51.         //调用整型int型非类型形参的方法为名为Ci,声明形式为template<class T1,int a> class Ci        Ci<int,GHIJKLMJKLNOPQMII//正确,数值R是一个int型常量,输出"class Ci g() int" 
    52.         const int a2=3;Ci<int,a2> mci1; mci1.g(); //正确,因为a2在这里是const型的常量。输出"class Ci g() int" 
    53.     //Ci<int,a> mci; //错误,int型变量a是局部变量,不是一个常量表达式。 
    54.     //Ci<int,e> mci; //错误,全局int型变量e也不是一个常量表达式。 
    55.     //调用int&型非类型形参的方法类名为Cip,声明形式为template<class T1,int &a>class Cip 
    56.     Cip<int,e> mcip;  //正确,对全局变量的引用或地址是常量表达式。 
    57.     //Cip<int,a> mcip1; //错误,局部变量的引用或地址不是常量表达式。 
    58.     //调用double*类型的非类形形参类名为Cd,声明形式为template<class T1,double *a>class Cd 
    59.     Cd<int,&ed> mcd; //正确,全局变量的引用或地址是常量表达式。 
    60.     //Cd<int,pe> mcd1; //错误,全局变量指针不是常量表达式。 
    61.     //double dd=aNGMIITbULcdefbbHIJKbgMIhh错误,局部变量的地址不是常量表达式,不能用作非类型形参的实参 
    62.     //Cd<int,&e> mcd;  //错误,非类型形参虽允许一些转换,但这个转换不能实现。 
    63.     //调用模板类型形参对象A<int> *的方法类名为Cc,声名形式为template<class T1,A<int>* m> class Cc 
    64.     Cc<int,&mw> mcc; mcc.g(); //正确,全局对象的地址或者引用是常量表达式 
    65.     //Cc<int,&ma> mcc;  //错误,局部变量的地址或引用不是常量表达式。 
    66.     //Cc<int,pec> mcc2;  //错误,全局对象的指针不是常量表达式。 
    67.     //调用非类型形参E&对象的引用的方法类名为Ce。声明形式为template<class T1,E &m> class Ce 
    68.     E me1; //Ce<int,me1> mce1; //错误,局部对象不是常量表达式 
    69.     Ce<int,me> mce;  //正确,全局对象的指针或引用是常量表达式。 
    70.     //非类型形参的转换示例,类名为Ci 
    71.     //非类型形参允许从数组到指针,从函数到指针的转换,const修饰符的转换,提升转换,整值转换,常规转换。 
    72.     const short s=3 ;Ci<int,s> mci ;//正确,虽然short型和int不完全匹配,但这里可以将short型转换为int型 
    73.     return 0; 

    与函数模板相同,类模板的声明语句也必须至于类声明的前面。有两个以上模板参数时,应使用逗号分开。使用含类模板的类定义对象时也必须在类名的后面带上“﹤实际类型﹥”的参数列表。类模板最常用于各种类包容关系的设计模型中。定义:

    Template ﹤类型参数表﹥ class 类名 {类声明体}

    在使用类模板时,应注意以下几点:

    在所有出现类模板的地方不能直接用类名表示,都应加上﹤…﹥

    在类模板定义体中,可以省略﹤…﹥

    一个类模板的各个实例之间没有特殊的联系(形成一个独立的类)如:Queue<int> qi 和Queue<string> qs,分别表示整数队列和字符队列

    实例化时机:在需要时实例化,比如定义指针或引用是不需要实例化,定义具体的变量或常量是会实例化,而访问对象的成员时会实例化。如 Queue<int> *q //不实例化Queue<> ,Queue<int> iq //实例化Queue<>,iq->add(2) //实例化Queue<>

    类模板中的友元

    非模板函数、类成为所有实例类的友元。如:

     
    1. Class Foo { void bar();}; 
    2. Template <class Type> 
    3. Class QueueItem 
    4.          Friend class Foobar;  //类Foobar不需要先定义或声明,并没有<> 
    5.          Frined void foo();    //函数foo() 
    6.          Frined void Foo::bar();//类Foo必须先定义 

    模板函数、模板类成为同类型实例类的友元。如:

     
    1. Template <class Type> class Foo {…}; 
    2. Template <class Type> void foo(QueueItem<Type>); 
    3. Template <class Type> class Queue{ void bar();}; 
    4. Template <class Type> class QueueItem 
    5.          Friend class Foo<Type>;  //模板类Foo需要先定义或声明,并带有<> 
    6.          Friend void foo(QueueItem<Type>); //模板函数foo()需要先定义或声明 
    7.          Friend void Queue<Type>::bar();   //模板类Queue必须先定义 

    模板函数、模板类成为不同类型实例类的友元。如:

     
    1. Template <class T> class QueueItem 
    2.          Template <class Type> friend class Foo; 
    3.          Template <class Type> friend void foo(QueueItem<Type>); 
    4.          Template <class Type> friend void Queue::bar(); 

    类模板的显示实例化:和函数模板的显示实例化一样都是以template 开始。比如template class A<int,int>;将类A显示实例化为两个int 型的类模板。这里要注意显示实例化后面不能有对象名,且以分号结束。显示实例化可以让程序员控制模板实例化发生的时间。

    1、类模板中有普通友元函数,友元类,模板友元函数和友元类。

    2、可以建立两种类模板的友元模板,即约束型的友元模板和非约束型的友元模板。

    3、非约束型友元模板:即类模板的友元模板类或者友元模板函数的任一实例都是外围类的任一实例的友元,也就是外围类和友元模板类或友元模板函数之间是多对多的关系

    4、约束型友元模板:即类模板的友元模板类或友元模板函数的一个特定实例只是外围类的相关的一个实例的友元。即外围类和友元模板类或友元模板函数之间是一对一的关系。

    5、约束型友元模板函数或友元类的建立:比如有前向声明:template<class T1> void g(T1 a); template<class T2> void g1(); template<class T3>class B;则template<class T>class A{friend void g<>(T a); friend void g1<T>(); friend class B<T>;};就建立了三个约束型友元模板,其中g和g1是函数,而B是类。注意其中的语法。这里g<int>型和类A<int>型是一对一的友元关系,g<double>和A<double>是一个一对一的友元关系。

    6、非约束型友元模板函数或友元类的建立:非约束型友元模板和外围类具有不同的模板形参,比如template<class T>class A{template<class T1> friend void g(T1 a); template<class T2> friend class B;}注意其中的语法,非约束型友元模板都要以template开头。要注意友元模板类,在类名B的后面没有尖括号。

    7、不存在部分约束型的友元模板或者友元类:比如template<class T> class A{template<class T1>friend void g(T1 a, T b);

    template<class T3>friend class B<T3,T>;}其中函数g具有template<class T1,class T2>void g(T1 a,T2 b)的形式。其中的函数g试图把第二个模板形参部分约束为类A的模板形参类型,但是这是无笑的,这种语法的结果是g函数的非约束型类友元函数,而对类B的友元声明则是一种语法错误。

    类模板中的模板成员(模板函数,模板类)和静态成员

    1、类模板中的模板函数和模板类的声明:与普通模板的声明方式相同,即都是以template 开始

    2、在类模板外定义类模板中的模板成员的方法:比如template<class  T1> class A {public:template<class T2> class B;

    template<class T3> void g(T3 a);};则在类模板外定义模板成员的方法为,template<class  T1> template<class T2> class A<T1>::B{};定义模板函数的方法为:template<class T1>

    template<class T3> void A<T1>::g(T3 a){}其中第一个template指明外围类的模板形参,第二个template指定模板成员的模板形参,而作用域解析运算符指明是来自哪个类的成员。

    3、实例化类模板的模板成员函数:比如上例中要实例化函数g()则方法为, A<int> m; m.g(2);这里外围类A的模板形参由尖括号中指出,而类中的模板函数的参数由整型值2推演出为int 型。

    4、创建类模板中的模板成员类的对象的方法:比如上例中要创建模板成员类B的方法为,A<int>::B<int> m1;A<int>::B<doble>m2;  A<double>::B<int> m3;在类模板成员B的前面要使用作用域解析运算符以指定来自哪个外围类,并且在尖括号中要指定创建哪个外围类的实例的对象。这里说明在类模板中定义模板类成员时就意味意该外围模板类的一个实例比如int 实例将包含有多个模板成员类的实例。比如这里类A的int 实例就有两个模板成员类B的int 和double两个实例版本。

    5、要访问类模板中的模板成员类的成员遵守嵌套类的规则,因为类模板中的模板成员类就是一个嵌套类。即外围类和嵌套类中的成员是相互独立的,要访问其中的成员只能通过嵌套类的指针,引用或对象的方式来访问。具体情况见嵌套类部分。

    6、类模板中的静态成员是类模板的所有实例所共享的。

     
    1. #include <iostream> 
    2. using namespace std; 
    3. template<class T1,class T2> class A{public:int a,b; static int e;}; 
    4. template<class T3,class T4> class B; 
    5. template<class T5,class T6> void g(T5 a,T6 b); 
    6. class C{public:void gc(){cout<<"class C gc()"<<endl;}}; 
    7. void g1(){cout<<"putong g1()"<<endl;} } 
    8. template<class T1,class T2>template<class T3,class T4}class A<T1,T2>::B{public:void gb(){cout<<"moban class B gb()"<<endl;}} 
    9. //在类模板外面定义类模板的模板成员类的方法 
    10. template<class T1,class T2>template<class T5,class T6}void A<T1,T2>::g(T5 a,T6 b){cout<<"moban g()"<<endl;}//在类模板外面定义类模板的模板成员函数的方法 
    11. template<class T1,class T2> int A<T1,T2>::e=0;//在类模板外面定义静态成员的方法。 
    12. int main() 
    13.     A<int,int> ma; 
    14.     ma.g(2,3);//创建模板类中模板成员函数的方法,在这里模板类A的模板形参被设为int,而模板成员函数的模板形参则由两个int型的整    数推演为int型。 
    15.     ma.e=1; A<int,int>::e=2;  //把类模板A的int,int型实例的静态成员设为。 
    16.     cout<<"ma.e="<<ma.e<<endl;  
    17.     A<int,double> ma1; 
    18.     cout<<"ma.e="<<ma1.e<<A<int,int>::e<<A<int,double>::e<<endl; //因为类模板A的int,int型实例和int,double实例是两个实例,所以这里的静态常量e的值不是三个二。 
    19.     A<int,int>::B<int,int> mb;  //声明模板类中模板成员类的方法。 
    20.     mb.gb();//调用嵌套类B的成员函数 
    21.     //mb.g(); //错误,函数g()是外围类的成员,嵌套类不能访问外围类的成员 
    22.     return 0; 

    简单模板实例,参数列表为基本类型:

     
    1. #include<iostream.h> 
    2. template<class T> 
    3. class Array 
    4. {    T *ar; 
    5. public
    6.         Array(int c){ar=new T[c];} 
    7. void init(int n,T x){ar[n]=x;    } 
    8.     T& operator[](int n){return ar[n];} 
    9. }; 
    10. void main() 
    11. {  
    12.     Array<int> array(5); 
    13.     cout<<"Please input every element's value:"<<endl; 
    14.     for(int i=0;i<5;i++) 
    15.     {  
    16.         cout<<"No."<<i+1<<':';   
    17.         cin>>array[i];   
    18.     } 

    类模板参数是类:

     
    1. #include<iostream.h> 
    2. class A 
    3. {    
    4.     int j; 
    5. public
    6.     A(){} 
    7.     A(int x):j(x){} 
    8.     A(A *x){j=x->j;} 
    9.     void operator!(){cout<<"J="<<j<<endl;} 
    10. };  
    11. template<class T> 
    12. class B 
    13. {   
    14.     int i; 
    15.      T *x; 
    16. public
    17.     B(int xa,T *p):i(xa){x=new T(p);} 
    18.     void operator!(){cout<<"I="<<i<<endl;!*x;} 
    19. }; 
    20.   
    21. void main() 
    22.     A a(1);        //最后的显示结果为: 
    23.     B<A> b(2,&a);  //I=2 
    24.     !b;           //J=1 

    Typename的使用:

     
    1. #include <iostream> 
    2. template<class T> class X  
    3. {  
    4.     typename T::id i; //如无typename看看情况如何 
    5. publicvoid f() 
    6.         { 
    7.             i.g(); 
    8.         } 
    9. };  
    10.   
    11. class Y  
    12. {  
    13. publicclass id  
    14.         {  
    15.             publicvoid g()  
    16.                     { 
    17.                         std::cout<<"Hello World!"<<std::endl; 
    18.                     }  
    19.         };  
    20. };  
    21.   
    22. int main()  
    23. {  
    24.     //Y y; 
    25.     X<Y> xy;  
    26.     xy.f();  
    27.     return 0; 

    Typename关键字告诉编译器把一个特殊的名字解释成一个类型,在下列情况下必须对一个name使用typename关键字:

    一个唯一的name(可以作为类型理解),嵌套在另一个类型中。

    依赖于一个模板参数,就是说,模板参数在某种程度上包含这个name。当模板参数使编译器在指认一个类型时便会产生误解。

    在定义模板时,typename和class作用基本相同,至于二者的其他关系没有什么区别,仅是历史原因,typename仅是一个新生代。

    复杂的模板类实例:

     
    1. #include<iostream.h> 
    2. #include<string.h> 
    3. class Student 
    4.     int number; 
    5.     static Student *ip; 
    6.     Student *p; 
    7. public
    8.     Student(){p=NULL;} 
    9.     Student(int n); 
    10.     static Student* get_first(){return ip;} 
    11.     int get_number(){return this->number;} 
    12.     Student* get_next(){return this->p;} 
    13. }; 
    14.   
    15. Student::Student(int n):number(n)  //依据学号的大小顺序将学生对象插入链表 
    16.     p=NULL; 
    17.     if(ip==NULL)ip=this;  //如果是第一个则使头指针指向该对象 
    18.     else{Student *temp=ip;       
    19.     if(n<ip->number){ip=this;p=temp;}//如学号小于第一个学生对象的学号则使头指针指向该对象 
    20.     else { 
    21.         while(temp) 
    22.         { 
    23.              
    24.             if(n<temp->p->number) 
    25.             { 
    26.                 p=temp->p;  //链中间对象的插入 
    27.                 temp->p=this
    28.                 break
    29.             }else  
    30.             {     
    31.                 if(temp->p->p==NULL)  //最后一个链的插入 
    32.                 { 
    33.                     temp->p->p=this;break
    34.                 }                    } 
    35.             temp=temp->p; 
    36.         } 
    37.     } 
    38.     } 
    39. Student* Student::ip=NULL; 
    40. template<class T> 
    41. class Class 
    42.     int num; 
    43.     T *p; 
    44. public
    45.        Class(){} 
    46.        Class(int n):num(n){p=NULL;} 
    47.        T* insert(int n){p=new T(n);return p;} 
    48.        void list_all_member(T* x) 
    49.        {   T *temp=x; 
    50.        while(temp) { cout<<temp->get_number()<<",";temp=temp->get_next();} 
    51.        } 
    52. }; 
    53. void main() 
    54. {  
    55.     Class<Student> x97x(9707); 
    56.     x97x.insert(23); 
    57.     x97x.insert(12); 
    58.     x97x.insert(38); 
    59.     x97x.insert(22); 
    60.     x97x.insert(32); 
    61.     x97x.list_all_member(Student::get_first()); 

    现在来讨论模板安全:模板根据参数的类型进行实例化。因为通常事先不知道其具体类型,所以也无法确切知道将在哪儿产生异常。程序员需要知道程序在什么地方发生了异常。下面看一个简单的模板类:

     
    1. Template <typename T> 
    2. Class Wrapper 
    3. Public: 
    4.          Wrapper(){} 
    5.          T get(){return value_;} 
    6.          T set(T const &value){value_=value;} 
    7. Private: 
    8.          T value_; 
    9.          Wrapper(Wrapper const &); 
    10.         Wrapper &operator=(Wrapper const &); 
    11. }; 

    实例化过程很简单,如Wrapper <int> i;因为Wrapper <int>只接受int或其引用,所以不会触及异常,Wrapper <int>不抛异常,也没有直接或者间接调用任何可能抛异常的函数,因此Wrapper <int>是异常安全的。

    现在再来看Wrapper<X>x,这里X是一个类。在这个定义里,编译器实例化了:

     
    1. Template <> Class Wrapper<X> 
    2. Public: 
    3.          Wrapper(){} 
    4.          X get(){return value_;} 
    5.          X set(X const &value){value_=value;} 
    6. Private: 
    7.          T value_; 
    8.          Wrapper(Wrapper const &); 
    9.         Wrapper &operator=(Wrapper const &); 
    10. }; 

    现在就有问题出现了:

    Wrapper<X> 包含了一个X的子对象。这个子对象需要构造,意味着调用X的构造函数,这个构造函数可能抛出异常。

    Wrapper<X>::get()产生并返回了一个X的临时对象。为了这个临时对象,get()调用了X的拷贝构造函数,这个函数可能抛出异常。

    Wrapper<X>::set()执行了表达式value_=value,他实际上调用了X的赋值运算。这个运算可能抛出异常。

    可以看到,同样的模板和同样的语句,但其含义不同。由于这样的不确定性,我们需要采用保守策略:假设Wrapper会根据类来实例化,而这些类在其成员上没有进行异常规格申明,则他们可能抛出异常。

    再假设Wrapper的异常规格申明承诺其成员不产生异常。至少必须在其成员上加上异常规格申明throw(),所以需要修补掉这些可能导致异常的地方:

    在Wrapper::Wrapper()中构造value_的过程。

    在Wrapper::get()中返回value_的过程。

    在Wrapper::set()中队value_的赋值过程。

    另外,在违背throw()的异常规格申明是,还要处理std::unexpected.

    再来看默认构造函数:

     
    1. Wrapper() throw() 
    2. Try:T() {} 
    3. Catch (…){} 

    虽然看上去不错,但它不能工作,根据C++标准:对构造函数或析构函数上的function-try-block,当控制权到达了异常处理函数的结束点是,被捕获的异常被再次抛出。对于一般的函数,此时是函数返回,等同于没有返回值的return 语句,对于定了返回类型的函数此时的行为未定义。换句话说,上面的程序相当于:

     
    1. X::X() throw() 
    2. Try: T (){} 
    3. Catch (…){ throw;} 

    这不是程序本来想要的结果,换成以下代码:

     
    1. X::X() throw() 
    2. Try: T (){} 
    3. Catch (…){ return;} 

    但是它却违背了标准:如果在构造函数上的function-try-block的异常处理函数体中出现了return语句,则程序是病态的。最终:无法用function-try-block快来实现构造函数的接口安全。

    引申原则1:尽可能使用构造函数不抛异常的基类或成员子对象。

    引申原则2:为了帮助别人实现原则1,不要从构造函数中抛出任何异常。

    其他方面的不再讨论,比如析构与关键字new等。总之,良好的设计必须满足以下两个原则:

    通过异常对象的存在来注视异常状态,并适当的做出反应。

    确保创造和传播异常对象不会造成更大的破坏。

    最终代码的参考将如下:

     
    1. template <typename T> 
    2. class wrapper 
    3. public
    4.     wrapper()     throw() : value_(NULL) 
    5.     {       
    6.         try  
    7.         {     
    8.             value_ = new T; 
    9.         } 
    10.         catch (...) {      } 
    11.     } 
    12.     ~wrapper() throw() 
    13.     {     
    14.         try  
    15.         {  
    16.             delete value_; 
    17.         } 
    18.         catch (...){operator delete(value_);} 
    19.     } 
    20.     bool get(T &value) const throw(){return assign(value, *value_);} 
    21.     bool set(T const &value) throw(){return assign(*value_, value);} 
    22. private
    23.     bool assign(T &to, T const &from) throw() 
    24.     { 
    25.         bool error(false); 
    26.         try{to = from; } 
    27.         catch (...) { error = true;} 
    28.         return error; 
    29.     } 
    30.     T *value_; 
    31.     wrapper(wrapper const &); 
    32.     wrapper &operator=(wrapper const &); 
    33. }; 
    34. void main() 
    35.     wrapper<int> mywrapper(); 

    可以像使用普通类的方法来使用模板类,这一点毫无疑问,例如:可以继承、创建一个从现有模板继承过来的并已经初始化的模板。现在,我们来看看模板的继承,如果vector已经为你做了很多事,但你还想加入sort()的功能,则可用下面代码来扩充。

     
    1. #ifndef SORTED 
    2. #define SORTED  
    3. #include<vector> 
    4.   
    5. template <class T> 
    6. class Sorted:public std::vector<T> 
    7. public
    8.         void sort(); 
    9. }; 
    10.   
    11. template <class T> 
    12. void Sorted<T>::sort() 
    13.     for (int i=size();i>0;i--) 
    14.     { 
    15.         for (int j=1;j<i;j++) 
    16.         { 
    17.             if (at(j-1)>at(j)) 
    18.             { 
    19.                 T t=at(j-1); 
    20.                 at(j-1)=at(j); 
    21.                 at(j)=t; 
    22.             } 
    23.         } 
    24.     } 
    25.   
    26. #endif 

    实现文件

     
    1. #include "123.h"  
    2. #include <iostream>  
    3. #include <string>  
    4. using namespace std;  
    5. char* words[] = {"is""running""big""dog""a"};  
    6. char* words2[] = { "this""that""theother" };  
    7. int main()  
    8. {  
    9.     Sorted<int> is;  
    10.     for(int i = 15; i >0; i--)    is.push_back(i);  
    11.     for(int l = 0; l < is.size(); l++)  cout << is[l] << ' ';  
    12.     cout << endl;  
    13.     is.sort();  
    14.     for(l = 0; l < is.size(); l++) cout << is[l] << ' ';  
    15.     cout << endl;  
    16.     Sorted<string*> ss;  
    17.     for(i = 0; i < 5; i++) ss.push_back(new string(words[i]));  
    18.     for(i = 0; i < ss.size(); i++) cout << *ss[i] << ' ';  
    19.     cout << endl;  
    20.     ss.sort();  
    21.     for(i = 0; i < ss.size(); i++) cout << *ss[i] << ' ';  
    22.     cout << endl;  
    23.     Sorted<char*> scp;  
    24.     for(i = 0; i < 3; i++) scp.push_back(words2[i]);  
    25.     for(i = 0; i < scp.size(); i++) cout << scp[i] << ' ';  
    26.     cout << endl;  
    27.     scp.sort();  
    28.     for(i = 0; i < scp.size(); i++) cout << scp[i] << ' ';  
    29.     cout << endl;  
    30.     return  0; 

    以上简单实现了模板的继承,读者可自行编写相关代码进行测试,并分析模板继承情况下,析构函数和构造函数等的消坏和初始化情况,这里不这讨论。

    注意:子类并不会从通用的模板基类继承而来,只能是从基类的某一个实例继承而来。

    现将模板的继承方式总结以下几点:

    基类是模板类的一个特定实例化的版本。比如:template <class T1> class B:public A<int>{}.

    基类是一个和子类相关的一个实例。比如:template <class T1>class B:public A<T1>{}。这时实例化基类就相应的被实例化一个和基类相同的实例版本,比如:B<int> b;模板B被实例化为int 版本,这时基类A也相应的被实例化为Int版本。

    如果基类是一个特定的实例化版本,这时子类可以不是一个模板,比如:class B:public A<int>{};。

    每次实例化一个模板,模板的代码都会被重新生成(除了inline标记的函数),如果一个模板某些函数不依赖于特定的类型参数而存在,那它们就可以放置在一个通用的基础类中,来阻止无意义的代码重生。

    Inline函数因不产生新的代码所以它们是自由的,在整个过程中,功能性的代码只是在我们创建基础类代码时产生了一次,而且,所属权的问题也因为增加了新的析构函数而解决。通常模板只有在需要的时候才实例化,对函数模板来说,这就意味着调用它时才被实例化,但对类模板来说,它更加明细化,只有在使用到模板中的某个函数式,函数才会被实例化,换句话说:只有用到的成员函数被实例化了。例如:

     
    1. #include <iostream.h> 
    2. class X  
    3. public:  
    4.     void x()  
    5.     {   
    6.         cout<<"This is fuction x()"<<endl; 
    7.     }  
    8. };  
    9. class Y  
    10. public:  
    11.     void y()  
    12.     {    
    13.         cout<<"This is fuction y()"<<endl;  
    14.     }  
    15. };  
    16.   
    17. template <typename T> class Z  
    18.     T t;  
    19. public:  
    20.     void a() { t.x(); }  
    21.     void b() { t.y(); }  
    22. };  
    23.   
    24. int main()  
    25.     Z<X> zx;  
    26.     zx.a(); // Doesn't create Z<X>::b()  
    27.     Z<Y> zy;  
    28.     zy.b(); // Doesn't create Z<Y>::a() 
    29.     return 0; 

    最后用模板技术演示list的的使用。

     
    1. // Template class for storing list elements 
    2. #include <iostream> 
    3. #include <string> 
    4. using namespace std; 
    5. template <class T>                          // Use template keyword 
    6. class ListElement                            //定义类ListElement,用于表示list对象 
    7. public
    8.     T data; 
    9.     ListElement<T> * next ; 
    10.     ListElement(T& i_d, ListElement <T>* i_n) 
    11.     : data(i_d),next(i_n) { } 
    12.     ListElement<T>* copy()                    // copy includes all next elements 
    13.     {     
    14.         return new ListElement(data,(next?next->copy():0));     
    15.     } 
    16. }; 
    17. template <class T>  
    18. class ListIterator        //定义类ListIterator,用于访问和操作list对象 
    19. {  
    20. public : 
    21.                                             //ListIterator(List<T>& l) ; 
    22.    T operator()() ; 
    23.    int operator++() ; 
    24.    int operator!() ; 
    25. public
    26.      ListElement<T>* rep ; 
    27. }; 
    28. template <class T> 
    29. T ListIterator<T>::operator() () 
    30. {  
    31.     if (rep) return rep->data; 
    32.     else  
    33.     { 
    34.         T tmp ;    return tmp ;                // Default value   
    35.     } 
    36. template <class T> 
    37. int ListIterator<T>::operator++() 
    38. {    
    39.     if (rep) 
    40.         rep = rep->next ;    
    41.     return (rep != 0) ; 
    42. template <class T> 
    43. int ListIterator<T>::operator!() 
    44. {    
    45.     return (rep != 0) ; 
    46. template <class T> 
    47. class List                //定义类List  
    48. public
    49.     friend class ListIterator<T> ; 
    50.     List(); 
    51.     List(const List&); 
    52.     ~List(); 
    53.     List<T>& operator=(const List<T>&); 
    54.                                             // typical list ops 
    55.     T head(); 
    56.     List<T> tail(); 
    57.     void add(T&); 
    58.     friend ostream& operator<<(ostream&, const List<T>&); 
    59. public
    60.     void clear() ;                            // Delete all list elements 
    61.     ListElement<T>* rep ; 
    62. }; 
    63.                                             // Default Constructor 
    64. template <class T> 
    65. List<T>::List(){ rep = 0 ; } 
    66.                                             // Copy Constructor 
    67. template <class T>List<T>::List(const List<T>& l) 
    68. {      
    69.     rep = l.rep ? l.rep->copy() : 0 ; 
    70.                                             // Overloaded assignment operator 
    71. template <class T> 
    72. List<T>& List<T>::operator=(const List<T>& l) 
    73.     if (rep != l.rep)    
    74.     {         
    75.         clear() ;         
    76.         rep = l.rep ? l.rep->copy() : 0 ;     
    77.     } 
    78.     return *this ; 
    79.                                             // Destructor 
    80. template <class T> 
    81. List<T>::~List(){  clear() ;} 
    82.                                             // Delete representation 
    83. template <class T> 
    84. void List<T>::clear() 
    85. {   while (rep) 
    86.     {   ListElement<T>* tmp = rep ; 
    87.         rep = rep->next ; 
    88.         delete tmp ; 
    89.     } 
    90.     rep = 0 ; 
    91.                                             // Add element to front of list 
    92. template <class T> 
    93. void List<T>::add(T& i) 
    94. {    
    95.     rep = new ListElement<T>(i,rep) ; 
    96.                                             // Return head of list or default value of type T 
    97. template <class T> 
    98. T List<T>::head() 
    99. {  
    100.     if (rep) return rep->data ;  
    101.     else  
    102.     { 
    103.         T tmp ;  
    104.         return tmp ; 
    105.     } 
    106.                                             // Return tail of list or empty list 
    107. template <class T> 
    108. List<T> List<T>::tail() 
    109. {    List<T> tmp ; 
    110.      if (rep) 
    111.        if (rep->next) tmp.rep = rep->next->copy() ; 
    112.      return tmp ; 
    113.                                             // Output operator 
    114. template <class T> 
    115. ostream& operator<<(ostream& os, const List<T>& l) 
    116.     if (l.rep) 
    117.     { 
    118.         ListElement<T>* p = l.rep ; 
    119.         os << "( " ; 
    120.         while (p){ os << p->data << " " ;   p = p->next ; } 
    121.         os << ")\n" ; 
    122.     } 
    123.     else 
    124.     os << "Empty list\n" ; 
    125.     return os ; 
    126. int main() 
    127.    List<int> l ;                            // Integer list 
    128.    cout << l ; 
    129.    int i=1; 
    130.    l.add(i) ; 
    131.    i=2; 
    132.    l.add(i) ; 
    133.    i=3; 
    134.    l.add(i) ; 
    135.    cout << "l is " << l << endl ; 
    136.    cout << "head of l is " << l.head() << endl ; 
    137.    List<int> m = l.tail() ; 
    138.    List<int> o ; 
    139.    o = m; 
    140.    i=4; 
    141.    m.add(i); 
    142.    cout << "m is " << m << endl ; 
    143.    cout << "o is " << o << endl ; 
    144.    List<char> clist ;                        // Character list 
    145.    char ch; 
    146.    ch='a'
    147.    clist.add(ch); 
    148.    ch='b'
    149.    clist.add(ch); 
    150.    cout << clist << endl ; 
    151.    List<string> ls ;                        // string List 
    152.    ls.add(string("hello")) ; 
    153.    ls.add(string("world")) ; 
    154.    cout << "List of strings" << endl ; 
    155.    cout << ls << endl ; 
    156.    List<List<int> > listlist ;                // List of lists of integer. Notice that lists of lists are possible 
    157.    listlist.add(o) ; 
    158.    listlist.add(m) ; 
    159.    cout << "List of lists of ints\n" ; 
    160.    cout << listlist << endl ; 
    161.    List<List<List<int> > > lllist ;            // List of lists of lists of integer 
    162.    lllist.add(listlist) ; 
    163.    lllist.add(listlist) ; 
    164.    cout << "List of lists of lists of ints\n" ; 
    165.    cout << lllist << "\n" ; 
    166.    List<List<string> > slist ;               // List of list of strings 
    167.    slist.add(ls) ; 
    168.    slist.add(ls) ; 
    169.    cout << "List of lists of strings\n" ; 
    170.    cout << slist << "\n" ; 
    171.    return 0 ; 

    注意:以上某一个实例好像未通过调试,基于时间本人已忘记,读者发现后可查看相关情况自行更正。

    原文链接:http://www.cnblogs.com/L-hq815/archive/2012/08/01/2619135.html

    展开全文
  • C++声明定义、类的定义、头文件作用、头文件重复引用,具名空间 转自:http://www.cnblogs.com/rocketfan/archive/2009/10/02/1577361.html  首先说我的补充:(对声明定义的深入理解和总结) 关于...
  • 模板匹配是一项在一幅图像中寻找与另一幅模板图像最匹配部分的技术,模板匹配技术是由MatchTemplate()函数完成,但是此项技术不是基于直方图的,是通过在输入图像上滑动图像块,对实际的图像块和输入图像进行匹配的...
  • 穿戴手势识别控制器

    千次阅读 2017-02-06 16:00:00
    穿戴手势识别控制器 2016年电子技术应用第7期  作者:徐军,刘春花,孟月霞,马静  摘 要: 随着穿戴电子设备的发展,基于手势识别的人机交互技术已经成为研究热点。为减小穿戴设备的体积...
  • 实现数据提取快速配置(适用于简单类型的文档)是...此外,我们还创建了一个易用工具(也提供了源代码形式),使用这个工具,用户可以在几分钟内创建数据提取解决方案模板。   这篇文章由开发人员撰写,并面向开发
  • 人脸识别之人脸对齐(一)--定义及作用

    万次阅读 多人点赞 2018-07-26 23:57:00
    原文: ... ... 人脸对齐任务即根据输入的人脸图像,自动定位出面部关键特征点,如眼睛、鼻尖、嘴角点、眉毛以及人脸各部件轮廓点等,如下图所示。... 这项技术的应用很广泛,比如自动人脸识别,表情识别以及人脸动画...
  • 嘉宾 | 向宇波编辑 | suiling来源 | AI科技大本营在线公开课出品 | AI科技大本营(ID:rgznai100)随着行业的发展和技术的成熟,文字识别(OCR...
  • blueski推荐 [2006-11-1]出处:计算机与信息技术作者:刘金彪 曹海泉 姚国平 摘要 本文提出了Word模板的4种制作方法,并对每种方法的具体制作和使用进行了详细论述,最后比较了4种方法的优缺点和适用场合,并提出...
  • 车牌识别

    千次阅读 2020-10-02 21:45:04
    随着21世纪经济全球化的到来,高速度、高效率的生活节奏,使车辆普及成为必然的趋势,交通管理自动化...尤其在高速公路收费系统中,实现不停车收费提高公路系统的运行效率,系统更具有不可替代的作用 关于车牌定位
  • 一文读懂人脸识别技术

    千次阅读 2019-11-12 16:55:19
    2019-08-27 17:06:26 本文内容涵盖人脸识别发展历程、市场...人脸识别(Face Recognition)是一种依据人的面部特征(如统计或几何特征等),自动进行身份识别的一种生物识别技术,又称为面像识别、人像识别、相貌识别...
  • 输出的含有标签如图 想要的结果是: 解决方法: [0]%> 在数据data前加 # 就解决了。...pre 元素可定义预格式化的文本。被包围在 pre 元素中的文本通常会保留空格和换行符。而文本也会呈现为等宽字体。
  • 人脸识别算法介绍

    万次阅读 2017-08-03 12:26:36
    主流的人脸识别技术基本上可以归结为三类,即:基于几何特征的方法、基于模板的方法和基于模型的方法。 1. 基于几何特征的方法是最早、最传统的方法,通常需要和其他算法结合才能有比较好的效果; 2. 基于模板...
  • 模板templates的使用

    万次阅读 2019-02-18 11:44:36
    模板及其渲染 模板查找路径 DTL模板语法 常用的模板标签 DTL常用过滤器 模块结构优化 加载静态文件 模板及其渲染 视图函数只是直接返回文本,而在实际生产环境中其实很少这样用,因为实际的页面大多是带有...
  • 语音识别概述

    万次阅读 多人点赞 2017-05-30 11:30:35
    一个基本的语音识别系统如下图,实现是正常工作流程,虚线是训练模式分类问题中的模板(这里就是声学模型,字典和语言模型)。 图1语音识别系统组件关系图 语音识别是把语音声波转换成文字。给定目标语音的...
  • 前后端模板

    千次阅读 2016-10-28 16:24:32
    原理:利用正则表达式识别模板标识,利用数据替换其中的标识符。 步骤: 利用正则分解出普通字符串和模板标识符 将模板标识符转换成指定的数据 生成待执行的语句 将数据填入执行,生成最终的字符串 将字符串写入...
  • Flask中的Jinja2模板使用

    千次阅读 2017-04-28 18:45:16
    两种逻辑分离将会使得代码难以理解和维护。Jinja2模板引擎模板是包含响应文本的文件。动态部分用占位变量表示,具体的值在请求的上下文中才能知道。渲染:使用真实值替代变量,返回最终的响应字符串。Flask用的是...
  • 基于matlab的车牌识别系统设计

    万次阅读 多人点赞 2018-06-01 16:00:14
    一个完整的车牌号识别系统要完成从图像采集到字符识别输出,过程相当复杂,基本可以分成硬件部分跟软件部分,硬件部分包括系统触发、图像采集,软件部分包括图像预处理、车牌定位、字符分割、字符识别四大部分,一个...
  • 模板继承其实并难理解,就好比类的继承一样,模板也可以定义一个基础模板(或者是布局),并且其中定义相关的区块(block),然后继承(extend)该基础模板的子模板中就可以对基础模板定义的区块进行重载。...
  • ecshop模板smarty foreach详解

    万次阅读 2012-05-22 12:07:19
    Smarty目录:/libs Smarty的功能类目录/tempalates 模板文件目录/templates_c 模板缓存文件目录/configs 配置文件目录/cache 缓存文件目录载入Smarty功能类:require(’路径/Smarty.class.php’);$smarty = new ...
  • 手势识别 技术

    万次阅读 多人点赞 2019-04-19 16:02:27
    手势识别可以分为基于穿戴设备的识别、基于触摸技术的识别和基于计算机视觉的识别。 一、基于穿戴设备的识别 1、在手势交互过程中,可以直接采集每根手指的弯曲姿态,通过数据归一化和平滑处理两根手指之间...
  • c++函数模板

    千次阅读 2021-07-19 13:40:29
    但编译器对宏定义替换不作检查,同时宏定义的传入参数不可有副作用,易出错,而函数模板模板函数则很好的规避了上述问题 定义格式: template <class NAME1,…> return_type function_name
  • 1、前两种都是属于模板匹配的方法,这些概念是在《数字图像处理高级应用》里的,其是移动匹配与向量匹配很像,只是移动匹配对灰度变换的鲁棒性不好。 这里说的移动匹配:就是把模板图像在原图像上进行移动,让后计算...
  • 人脸识别笔记

    千次阅读 2019-07-01 16:03:43
    人脸识别笔记 参考资料: 人脸识别技术看这一篇就够了(附国内人脸识别20强公司) 人脸识别的十个关键技术组成及原理 人脸识别技术百度百科 人脸识别技术及应用,了解一下 深度干货!一文读懂人脸识别技术(建议收藏...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,899
精华内容 29,559
关键字:

不可识别的模板声明定义