精华内容
下载资源
问答
  • RFC976 UUCP 邮件互换格式标准

    千次阅读 2004-08-18 10:50:00
    大部分情况下都可以根据给定的地址判定地址的类型。但是对于@左侧包含“a!” 的混合地址,如a!b@c就出现了混淆:即可以解释为(a!b)@c.d,也可以解释为a!(b@c.d)。这 两种解释都有意义,前者用于RFC822,后者是UUCP...
    组织:中国互动出版网(http://www.china-pub.com/)
    RFC文档中文翻译计划(http://www.china-pub.com/compters/emook/aboutemook.htm)
    E-mail:ouyang@china-pub.com
    译者:王安鹏(anpengwang    anpengwang@263.net)
    译文发布时间:2001-5-24
    版权:本中文翻译文档版权归中国互动出版网所有。可以用于非商业用途自由转载,但必须
    保留本文档的翻译及版权信息。
    
    
    Network Working Group                                    Mark. R. Horton
    Request for Comments: 976                              Bell Laboratories
    February 1986
    
    
    UUCP邮件交换格式标准
    (RFC976 UUCP Mail Interchange Format Standard)
    
    
    备忘录状态
    为了适应维护ARPA网上不同项目的状态和进展的当前情况的要求,特为社区成员发布
    本RFC。本文档的内容截止到发布之日是精确的,但目的在于进一步改进。后续的RFC将
    会反映这些改进。
       本文档定义了UUCP项目中两台机器之间传递邮件消息的标准格式。本文没有涉及单台
    机器上消息的存储格式,也不包括一台机器从另一台机器上获取数据的底层传输机制。本文
    讲述了UUCP区中的主机应遵循的标准。本备忘录的分发不受限制。
    
    目录
    1.  简介	1
    2.  基础	2
    2.1  混合地址(Hybrid Addresses)	2
    2.2  传输	3
    2.3  批处理SMTP	3
    2.4  信封(Envelope)	4
    2.5  邮件路由	5
    3.  算法	5
    4.  例子	6
    5.  结论	7
    6.  参考	8
    
    1.  简介
    本文的目的在于定义UUCP项目中主机之间传递邮件消息的标准格式,没有讨论消息在
    一台机器上的存储格式,也不涉及一台机器从另一台机器上获取数据的底层传输机制。我们
    假定远程执行rmail(或者等价的)命令是UUCP网络的基本操作。
    一条基本法则是:如果我们试图发明一种新的标准,通常无法与现有的系统兼容。世界
    上已经有太多的(互相矛盾的)标准,引起了混淆,比如a!b@c.d按照旧的UUCP标准被解
    释为a!(b@c.d),而在Internet世界里则被解释为(a!b)@c.d。(两个标准都不支持括号,否则
    就可以兼容了。外壳(shell)和UUCP传输机制同样存在严重的问题)。
    ARPA社区已经定义了明确的、具有完善文档的、可扩展的标准族,我们也选择这些标
    准应用于UUCP区。(UUCP区是使用UUCP连接并注册到UUCP项目的社区的子集,代表
    一个管理实体。)因为实际的传输机制取决于两台主机的安排,可能包括UUCP、SMTP、
    NMDF或者其它工具,我们选用RFC920(域)和RFC822(邮件格式)作为UUCP区的标
    准。所有系统间的邮件传输都应遵循这两个标准。另外,如果ARPA社区在以后改变了他
    们的标准,我们也将修改我们的标准以保证与之兼容,以便提供一个合理的软件升级时间。
    本文详述了RFC822和RFC920在UUCP世界中的解释,说明了如何对信封编码以及在
    混合实现环境中如何实现UUCP寻路。
    
    2.  基础
    消息可以分为两部分:信封和消息本身。信封包含邮件传输服务所需要的信息,消息包
    含对收发方有用的信息。消息分为首部和主体。有时候中间主机会改变消息(如增加Received
    行),但除非是网关需要改变传输格式,中间主机一般不得修改消息本身。在UUCP世界中,
    信封包括“目的地址”(通常表现为rmail命令的参数)和“源地址”(通常由消息的第一行
    或者最初几行表示,以“From”或者“>From”开始,又称为“From行”)。RFC32的报头
    行(包括“From:”和“To:”)作为消息的一部分是消息体本身的文本。
    UUCP在运输层及以下各层使用短主机名,如“ucbvax”。我们把这种短名称为“6字符
    名”,因为任何UUCP的实现都至少把前6个字符视为有效的。(有一些把前7个或者前14
    个字符视为有效,但我们必须使用最低的通用标准。)UUCP名可以长于6个字符,但其前
    6个必须各不相同。RFC920域的名称,如“ucbvax Berkeley.EDU”称为“域名”。这两个名
    是不同的。大小写对于6字符名被认为是不同的,但对于域名则认为是相同的。6字符名后
    加上“.UUCP”,如“ubcvax.UUCP”在过去作为对使用6字符名的主机的域格式的引用。
    随着对组织化的域名如“ucbvax.Berkelry.EDU”的支持,这一类名称正在逐步淘汰。
    2.1  混合地址(Hybrid Addresses)
    在UUCP世界中主要使用两种邮件地址语法:旧式UUCP软件使用的“a!b!c!user”(完
    全路径)格式指明了传送邮件到目的地址的路线;遵循RFC822的“user@domain”(域)语
    法格式。大部分情况下都可以根据给定的地址判定地址的类型。但是对于@左侧包含“a!”
    的混合地址,如a!b@c就出现了混淆:即可以解释为(a!b)@c.d,也可以解释为a!(b@c.d)。这
    两种解释都有意义,前者用于RFC822,后者是UUCP软件事实上的标准。
    由于混合地址带来的混乱,我们建议所有的运输层软件在任何时候都应该避免使用混合
    地址。纯粹的完全地址语法可以用来澄清这种混淆,上例中的第一种解释可以写为“c.d!a!b”,
    第二种解释写为“a!c.d!b”。我们建议所有的实现都是用这种“完全域”语法,除非他们确
    实知道下一台机器上运行什么。
    按照RFC822和AT&T消息传输体系,我们建议所有允许混合地址的主机采用(a!b)@c.d
    这种解释。
    
    2.2  传输
    因为许多UUCP域不支持SMTP,我们把用于“远程执行”的方法定义在传输机制的
    基础上。要“远程执行”的命令与其标准输出信息应一起读作:rmail user@domain ...。参数
    user@domain必须符合RFC920和RFC822。允许包含多个地址参数,这样把同一个消息发
    往多个接收方时可以节省传输时间。
    另一种方式是“rmail domain!user”,其中“domain”至少包含一个逗点而且不含“!”。
    这种表示可以被准确地解释为user@domain,可以通过旧式的UUCP主机传输消息而无需担
    心地址被改变。“user”字符串可以包含除“@”之外的任意字符,禁止该字符是因为无法
    确定中间主机如何处理它。(同样建议避免使用“%”,有些主机把“%”视为“@”的同义
    字。)不过,如果传输路径包含不理解域的主机,下面的格式是可能的:
          rmail a!b!c!domain!user
    域至少要包含一个逗点,因而可以与6字符的UUCP站点名区分开。(单层的域没有逗
    点,应在尾部增加额外的逗点,比如Mark.Horton@att 就成了“att.!Mark.Horton”。把!格式
    改为@格式的解释器应该删除尾部逗点——如果有的话。)我们不希望发生此类情况,除非
    本地网络使用类似user@host的地址。
    简单的应用可以只使用domain!user语法(而不是user@domian),因为这种方式对3类
    网关(参见节3.5)也是安全的。
    
    2.3  批处理SMTP
    符合标准的实现可能会选择支持一种称为“批处理SMTP”的协议。SMTP(简单邮件
    传输协议)是ARPA社区的标准邮件传输协议(RFC821),BITNET和Mailnet也使用该协
    议。因为SMTP被设计为交互式的,把一系列命令组成以批发到远程机器上成批执行是可
    能的。BSMTP的一个优点是UNIX外壳不参与消息的解释,因而电子信息中可以包含空格
    和括号这样的特殊字符(这些字符在X.400地址中将会非常普遍)。
    为了使UNIX支持BSMTP,符合标准的主机应当把用户的邮件命令“b-smtp”解释为
    批处理SMTP(我们使用“b-smtp”而不是“bsmtp”是因为后者与一个登录名冲突)。因为
    许多邮件系统把包含单个逗点一行当作“文件尾”的标志处理,而SMTP把逗点用作必需
    的文件尾标志,为了区分出报头,我们在BSMTP的每一行增加一个特殊的“#”。在邮件发
    送系统中实现这一点的简单方法是包括如下别名:
          b-smtp: "|egrep '^#' | sed 's/^#//' | /usr/lib/sendmail -bs"
    这样就可以把命令输送给SMTP解释器。更好的方案还要同时检查错误并把错误信息反馈
    给发送方。
    下面的例子说明了一个从seismo.CSS.GOV发往cbosgd.ATT.COM的BSMTP消息。这
    个例子是通过UUCP连接传递给命令“rmail b-smtp”的文件。注意RFC- 822 消息位于DATA
    行和逗点行(最后一行)之间。信封信息在MAIL FROM和RCPT TO行中传递。发送系统
    的名称在HELO行中。实际的信封信息(带有“#”的行以上的部分)被忽略了,不一定要
    出现。
          From foo!bar Sun Jan 12 23:59:00 1986 remote from seismo Date:
          Tue, 18 Feb 86 13:07:36 EST
          From: mark@ucbvax.Berkeley.EDU
          Message-Id: <8602181807.AA10228@mark@ucbvax.Berkeley.EDU> To:
          b-smtp@cbosgd.ATT.COM
    
          #HELO seismo.CSS.GOV
          #MAIL FROM:<mark@ucbvax.Berkeley.EDU>
          #RCPT TO:<mark@cbosgd.ATT.COM>
          #DATA
          #Date: Tue, 18 Feb 86 13:07:36 EST
          #From: mark@ucbvax.Berkeley.EDU
          #Message-Id: <8602181807.AA10228@mark@ucbvax.Berkeley.EDU> #To:
          mark@cbosgd.ATT.COM
          #
          #This is a sample message.
          #.
          #QUIT
    
    2.4  信封(Envelope)
    命令的标准输入应该以单独的一行:From domain!user date remote from system开始,后
    面紧跟着RFC822格式的报头和消息主体。可能在该行前还有其他的FROM行——这些行
    是可以增加的,消息途经的每个系统增加一行。“系统字段”也可能堆叠成单独一行,在
    “user”字符串中包含许多“!”。“From”前面可能还会有“>”字符。一般说来,这些“信
    封”信息应该与旧式的UUCP邮件一样遵从相同的约定。主要的区别是当系统名紧凑书写
    时,如果旧式的写法是a!b!c!mysys!me,新的写法改为a!b!c!mysys!domain!me,其中“domain”
    至少包含一个逗点符号,“mysys”通常是称为“domain”的系统的6字符UUCP名。如果
    “domain!”是多余的,就可以在信封中——源路径或者目的地址——省略掉。
    如果需要把信息包装成只有一个FROM行,接收系统可能会丢弃多余的“From_”行。
    它把“path!domain!user”和“信封”信息——包括消息发送方的地址,可能还生成新的一
    行如Received或Sent-By,其中保存着转发日期和转发系统——一起发送出去。(不建议使
    用Received,因为这样的行可能在真正增加该行的系统之前被其他的系统添加,而其他的系
    统可能事实上也包括一个Received行。Sent-By行与Received行类似,但日期不需要改为
    RFC822格式,而且不主张由名称被提及的系统提前增加该行。)
    如果接收系统继续把消息转发给另一个系统,它就会在前面增加一个FROM行,给处于
    发送方相同的user@domain地址并加上自身的系统名。如果接收系统把消息保存到本地的信
    箱内,建议仅在消息前生成一个FROM行并保存日期(使用相同的格式,因为有些邮件阅
    读程序对这种格式是敏感的),而不是用“remote from system”语法格式。
    注意:如果中间系统在user@domain语法格式地址——无论是信封还是消息体中——前
    面增加文本如“system!”,都是不符合本标准和RFC822规范的。
    
    2.5  邮件路由
    为了正确地发送邮件,有时候需要了解目的系统或者中间系统运行了什么软件或者遵从
    什么样的约定。我们曾经试图尽量减少必要的信息量,但是对子域的支持可能需要在不同条
    件下使用不同的方法。为了预报其他系统的行为方式,我们把主机分为三类。这三类包括:
    
    一类 仅使用旧式的UUCP“!”路径。我们设想主机理解本地用户名:“rmail user”和完
    全路径“rmail host1!host2!user”,但我们不对主机做更多的假定。如果没有关于某
    台主机的任何信息,我们可以毫无问题地把它作为第一类处理,因为我们没有对
    其如何处理混合地址作任何假设。
    
       二类 旧式的UUCP“!”路径和4.2BSD格式的域解析。我们假设除了具有一类主机的功
    能外,还能够理解“rmail user@domain”,其中“domain”位于UUCP区之外但主
    机可以识别。二类主机不必理解“domain!user”,也不需要路由器。符合RFC920
    标准的非UUCP域中的主机被认为是二类主机,即使也可能识别“host!user”。
    
       三类 具有一类和二类主机的全部功能。另外,三类主机还能够为相距较远的主机发送
    UUCP邮件,并且能够理解如前所述的语法“ramil domain!user”。所有连接到UUCP
    的网关必须是第三类。
    本文档描述了三类主机必须具有的功能。一类和二类主机已经存在,并将继续存在相当
    长的一段时间,但被视为“过时的系统”并最终将升级到3类主机的状态。
    
    3.  算法
    通过UUCP连接传递消息给地址user@domain的算法可以概述如下:
    
          a.  如果地址的实际格式是@domain1:user@domain2,就把“domain1”而不是
    “domain2”保留下来作为“doamin”,完整的格式读为“domain1!domain2!user”。
          b.  确定本地可以识别的“domain”中的最明确的部分,记作“d:”,该部分应该是
    “domain”的后缀。这项工作可以通过扫描一个表来完成,表项按照从特殊到一
    般的顺序排列,比较表项与“domain”检查该表项是否与“domain”的尾部匹配。
    例如,对于地址mark@osgd.cb.att.com,如果本地主机能够识别“uucp”和“att.com”,
    那么d就应该是“att.com”。表的最后一项是空字符串,与完全无法识别的域匹配。
          c.  查看基本表项(found table entry),寻找网关名(g:)和通往g的UUCP“!”格
    式的路径“r:”。G不一定要与本地主机直接相连,但应视作连接域d的网关。(对
    于给定的d,在不同的主机上g和r可能具有不同的值,不过g通常是一样的) 
          d.  根据r的开始部分查找“下一跳”的主机n,n总是直接与本地主机相连。
          e.  如果可能则确定g和n的类型。
          f.  建立n能够解释的适当的目标字符串s(见下面)。
    g.	把消息及目标信息s传递给n。
    如果环境中包括其它类型的不使用UUCP“!”解析的网络,表中可能还会有附加的
    信息,如使用的连接类型。路径信息在其他的环境中可能被替换为那个网络的特殊信
    息。
    上述第二步(b)中提到的表中的第一项一般是非常精确的,能够直接构造知名的路径
    而无需通过域树寻路。域树仅保留用于下列情况:没有更详尽多的信息;信息量很少;默认
    路径是最佳的选择。如果存在更好的路径就可以把该信息写入表中。如果主机有大量的信息
    传送给第二个主机,一般希望在两台主机之间建立直接的UUCP连接并为它们建立相应的
    表项以便直接传递邮件,即使两台主机位于不同的域中。路径表的构造应该为最大的通信量
    保持最短最便宜的路径。
    这里对目标字符串n(上述第六步f)的构造提供几点提示。如果发送站点确定下一跳是
    三类主机,那么“envelope recipient”信息(rmail的s参数)既可以使用域“!”格式
    (host.com!user),也可以采用域“@”格式(user@host.com)。如果下一跳步不是三类主机,
    或者发送站点不能确定,那么应尽可能使用“!”格式,因为无法预知下一跳会如何处理混
    合地址。
    如果已知网关是第三类,可以使用域“!”格式,但是如果发送站点不能确定其类型,或
    者查找中目标字符串完全匹配(而不是与某个父域匹配),则应使用6字符“!”格式“r!user”,
    如“dumbhost!host!user”。如果网关看来实际上是一个子域的网关,即与一个父域匹配(如
    地址user@host.gateway.com,表中没有找到host.gateway.com但发现了gateway.com),可以
    把它假定为第三类。这样在一定程度上可以安全使用如
    dumbhost!domain!host.domain.com!user之类的路径。如果存在到目标主机的直接连接,可以
    使用user@domain或者domain!user两种语法格式。
    符合本标准的主机是三类主机,所有的子域网关必须是三类主机。
    
    4.  例子
    假设主机A.D.COM 向主机C.D.COM发送邮件。设两台主机的6字符名分别为aname
    和dname,途径中间主机bname。
       主机A的用户输入:   mail user@c.d.com
       用户界面生成一个文件并使用命令(如sendmail user@c.d.com < file)把它传递给传输机
    制,文件内容如下:
          Date:  9 Jan 1985   8:39 EST
          From: myname@A.D.COM (My Name)
          Subject: sample message
          To: user@c.d.com
    
          This is a sample message
    传输机制查找到c.d.com的路径,但在数据库中没有找到;于是寻找d.com,发现其路
    径是bname!dname!%s,而且发现c.cd.com是三类主机。然后加入c.d.com!user,就得到了路
    径bname!dname!c.d.com!user。(如果发现c.d.com的路径是bname!cname!%s,结果路径
    bname!cname!user中的域将被忽略,因为无法确认目标主机属于哪一类。)
    传输机制预备一个FROM行并把它传递给uux: uux - bname!rmail dname!c.d.com!user < 
    file2,file2的内容包括:
          From A.D.COM!user Wed Jan  9 12:43:35 1985 remote from aname Date:
          9 Jan 1985   8:39 EST
          From: myname@A.D.COM (My Name)
          Subject: sample message
          To: user@c.d.com
    
          This is a sample message
    
       (注意消息尾部的空行——至少需要一个空行。)这将导致B主机执行命令:rmail 
    dname!c.d.com!user。B预备了它自己的FROM行并继续转发邮件:uux - dname!rmail 
    c.d.com!user < file3,file3的内容包括:
    
          From nuucp Wed Jan  9 12:43:35 1985 remote from bname >From
          A.D.COM!user Wed Jan  9 11:21:48 1985 remote from aname Date:  9
          Jan 1985   8:39 EST
          From: myname@A.D.COM (My Name)
          Subject: sample message
          To: user@c.d.com
    
          This is a sample message
        C主机执行命令:rmail c.d.com!user并压缩FROM行,然后把消息保存到本地——可能
    使用相同的格式:
    
          From bname!aname!A.D.COM!user Wed Jan  9 12:43:35 1985 Date:  9
          Jan 1985   8:39 EST
          From: myname@A.D.COM (My Name)
          Subject: sample message
          To: user@c.d.com
    
          This is a sample message
    
    5.  结论
        符合本标准的主机可以接受如下所有的格式:
    
          rmail localuser               (user中不含“!”、“%”、“@”)
          rmail hosta!hostb!user         (user中不含“!”、“%”、“@”)
          rmail user@domain           (域中只有逗点“.”)
          rmail domain!user            (域中至少包含一个逗点“.”)
          rmail domain.!user            (域中没有圆点的情形)
        消息的信封部分(FROM行)应遵循现有的约定使用“!”路径。消息的首部(Word:
    行,如Date:、From:、To:和Subject:)必须符合RFC822规范。所有首部地址必须采用@格
    式。原始站点应确保地址符合RFC822,不能要求转发站点或者网关把地址转换为合法的
    RFC822地址。(同样转发站点或者网关也不得把合法的RFC822地址user@domain转化成不
    符合RFC822的地址gateway!user@domain,即使要转发给一类UUCP主机。)
    
    6.  参考
    
       [1]  Postel, J., "Simple Mail Transfer Protocol", RFC-821,
            USC/Information Sciences Institute, August, 1982.
    
       [2]  Crocker, D., "Standard for the Format of ARPA Internet Text
            Messages", RFC-822, Department of Electrical Engineering,
            University of Delaware, August, 1982.
    
       [3]  Postel, J., and J. K. Reynolds, "Domain Requirements", RFC-920,
            USC/Information Sciences Institute, October, 1984.
    
    RFC976 UUCP Mail Interchange Format Standard                   UUCP邮件交换格式标准
    
    
    1
    RFC文档中文翻译计划
    
    展开全文
  • 期货与互换

    2020-09-16 22:03:02
    概念 在这里,期货就不多做介绍了,介绍下互换互换是指两个或两个以上当事人在约定的时间内,按照商定的条件交换一系列现金流的合约(互换可以看作... 商品互换:是一种特殊类型的金融交易,交易双方为了管理商品

    概念

    在这里,期货就不多做介绍了,介绍下互换。

    互换是指两个或两个以上当事人在约定的时间内,按照商定的条件交换一系列现金流的合约(互换可以看作是一系列远期的组合,远期合约可以看成仅交换一次现金流的互换)

    种类

    • 利率互换:是指双方同意在未来的一定期限内根据同种货币的同样的名义本金交换现金流,其中一方的现金根据浮动利率计算出来,而另一方的现金流根据固定利率计算。
    • 货币互换:是指将一种货币的本金和固定利息与另一货币的等价本金和固定利息进行交换。
    • 商品互换:是一种特殊类型的金融交易,交易双方为了管理商品价格风险,同意交换与商品价格有关的现金流。它包括固定价格及浮动价格的商品价格互换和商品价格与利率的互换。
    • 其它互换:股权互换、信用互换、气候互换和互换期权等。

    其中利率互换和货币互换是最常见也最重要的互换种类。

    有一个国际组织ISDA (International Swaps and Derivatives Association) 国际掉期交易协会.

    掉期和互换的英文都是SWAP,两者有一定的区别。掉期合同是一种协议,规定了合同双方在一定时间段内交换一系列现金流的协议,交换发生在合同预置好的日期,通常只交换现金流净值。外汇掉期是指在外汇市场上买进即期外汇的同时又卖出同种货币的远期外汇,或者卖出即期外汇的同时又买进同种货币的远期外汇,也就是说在同一笔交易中将一笔即期和一笔远期业务合在一起做,或者说在一笔业务中将借贷业务合在一起做。

    掉期交易的操作涉及即期交易与远期交易或买卖的同时进行,类型有即期对远期的掉期交易(spot-forward swaps)一天掉期交易(one-day swaps)远期对远期的掉期交易(forward-forward swaps)。 而互换则是一系列远期的组合。

    对比互换和期货

      期货交易 互换交易
    基础相同 远期合约是期货和互换的基础,期货和互换是对远期合约在不同方面创新后的衍生工具。因此,远期协议可以被用来给期货定价,也可以被用来给互换定价。
    交易对象标准化程度不同 商品品种、数量、质量、等级、交货时间、交货地点等都是标准化的,唯一的变量是价格 标的物及其数量、质量、等级均有交易双方自行协商决定,是非标准化合同
    成交方式不同 在交易所组织的有形的公开市场内通过电子交易系统撮合成交。价格具有公开性、权威性 互换交易一般无固定的交易场所和交易时间,可以在银行间市场或者柜台市场的交易商之间进行,也可以与最终客户直接交易,主要通过人工询价的方式撮合成交。
    合约双方关系不同 合约履行不取决于交易对手,而取决于结算机构在期货交易中充当中央对手的角色。期货结算机构是所有买方的卖方,是所有卖方的买方。交易者无须关心交易对手是谁、信用如何,市场信用度很高。 交易双方直接签订,一对一,违约风险取决于对手的信用
    展开全文
  • CString 和 string的互换

    2012-11-22 13:48:33
    首先,CString和string都是C++中的字符串模板类,string作为标准模板类(STL)定义的字符串类,已经纳入C++标准之中;而CString(typedef CStringT > CString)是Visual C++中最常用的字符串类,继承自CSimpleStringT类...

    首先,CString和string都是C++中的字符串模板类,string作为标准模板类(STL)定义的字符串类,已经纳入C++标准之中;而CString(typedef CStringT > CString)是Visual C++中最常用的字符串类,继承自CSimpleStringT类,主要应用在MFC和ATL编程中,主要数据类型有char(应用于ANSI)、wchar_t(unicode)、TCHAR(ANSI与unicode均可)。

    再说它们的构造。string几乎可以从所有的字符串构造而来,包括CString和char*;而CString只能从基本的字符串变量构造而来,如char*。

    CString和string的相互转换:

    CString to std::string:

    方法一:
    USES_CONVERSION;
    CString CStr;
    CStr = _T("CString to string");
    char* temp_char = W2A(CStr);
    std::string str = temp_char;
    
    方法二:
    CString CStr;
    CStr = _T("CString to string");
    std::string str = CStr.GetBuffer(0);

    std::string to CString:

    std::string str = "string to CString";
    CString CStr = str.c_str();
    展开全文
  • 文章目录1、数据类型1.1、数值类型1.1.1、整型(整数类型)1.1.2、浮点型(小数类型)1.1.3、复数1.2、bool类型(布尔类型)1.3、字符串类型1.3.1、定义字符串1.3.2、字符串拼接符“+”1.3.3、字符串实现基于 UTF-8 ...

    1、数据类型

    1.1、数值类型

    数值类型分为以下几种:整数、浮点数、复数。

    1.1.1、整型(整数类型)

    Go语言提供了有符号和无符号的整数类型,其中包括 int8、int16、int32 和 int64 四种大小截然不同的有符号整数类型,分别对应 8、16、32、64 bit(二进制位)大小的有符号整数,与此对应的是 uint8、uint16、uint32 和 uint64 四种无符号整数类型。

    用来表示 Unicode 字符的 rune 类型和 int32 类型是等价的,通常用于表示一个 Unicode 码点。这两个名称可以互换使用。同样,byte 和 uint8 也是等价类型,byte 类型一般用于强调数值是一个原始的数据而不是一个小的整数。最后,还有一种无符号的整数类型 uintptr,它没有指定具体的 bit 大小但是足以容纳指针。

    尽管在某些特定的运行环境下 int、uint 和 uintptr 的大小可能相等,但是它们依然是不同的类型,比如 int 和 int32,虽然 int 类型的大小也可能是 32 bit,但是在需要把 int 类型当做 int32 类型使用的时候必须显示的对类型进行转换,反之亦然。

    1.1.2、浮点型(小数类型)

    Go语言提供了两种精度的浮点数 float32 和 float64。
    一个 float32 类型的浮点数可以提供大约 6 个十进制数的精度,而 float64 则可以提供约 15 个十进制数的精度,通常应该优先使用 float64 类型,因为 float32 类型的累计计算误差很容易扩散,并且 float32 能精确表示的正整数并不是很大。例如:

    var f float32 = 16777216 // 1 << 24
    fmt.Println(f == f+1)    // "true"!
    

    浮点数在声明的时候可以只写整数部分或者小数部分,像下面这样:

    const e = .71828 // 0.71828
    const f = 1.     // 1
    

    很小或很大的数最好用科学计数法书写,通过 e 或 E 来指定指数部分:

    const Avogadro = 6.02214129e23  // 阿伏伽德罗常数
    const Planck   = 6.62606957e-34 // 普朗克常数
    

    用 Printf 函数打印浮点数时可以使用“%f”来控制保留几位小数,例如:

    fmt.Printf("%f\n", math.Pi)		//3.141593
    fmt.Printf("%.2f\n", math.Pi)	//3.14
    

    1.1.3、复数

    复数是由两个浮点数表示的,其中一个表示实部(real),一个表示虚部(imag)。Go语言中复数的类型有两种,分别是 complex128(64 位实数和虚数)和 complex64(32 位实数和虚数),其中 complex128 为复数的默认类型。

    复数的值由三部分组成 RE + IMi,其中 RE 是实数部分,IM 是虚数部分,RE 和 IM 均为 float 类型,而最后的 i 是虚数单位。
    声明复数的语法格式如下所示:

    var name complex128 = complex(x, y)
    

    其中 name 为复数的变量名,complex128 为复数的类型,“=”后面的 complex 为Go语言的内置函数用于为复数赋值,x、y 分别表示构成该复数的两个 float64 类型的数值,x 为实部,y 为虚部。

    上面的声明语句也可以简写为下面的形式:

    name := complex(x, y)
    

    对于一个复数z := complex(x, y),可以通过Go语言的内置函数real(z)来获得该复数的实部,也就是 x;通过imag(z)获得该复数的虚部,也就是 y。例如:

    var x complex128 = complex(1, 2) // 1+2i
    var y complex128 = complex(3, 4) // 3+4i
    fmt.Println(x*y)                 // "(-5+10i)"
    fmt.Println(real(x*y))           // "-5"
    fmt.Println(imag(x*y))           // "10"
    

    复数也可以用==!=进行相等比较,只有两个复数的实部和虚部都相等的时候它们才是相等的。
    Go语言内置的 math/cmplx 包中提供了很多操作复数的公共方法,实际操作中建议大家使用复数默认的 complex128 类型,因为这些内置的包中都使用 complex128 类型作为参数。

    1.2、bool类型(布尔类型)

    一个布尔类型的值只有两种:true 或 false。if 和 for 语句的条件部分都是布尔类型的值,并且==<等比较操作也会产生布尔型的值。

    一元操作符!对应逻辑非操作,因此!true的值为 false,更复杂一些的写法是(!true == false) == true,实际开发中我们应尽量采用比较简洁的布尔表达式,就像用 x 来表示x==true

    Go语言对于值之间的比较有非常严格的限制,只有两个相同类型的值才可以进行比较,如果值的类型是接口(interface),那么它们也必须都实现了相同的接口。如果其中一个值是常量,那么另外一个值可以不是常量,但是类型必须和该常量类型相同。如果以上条件都不满足,则必须将其中一个值的类型转换为和另外一个值的类型相同之后才可以进行比较。

    布尔值可以和 &&(AND)和 ||(OR)操作符结合,并且有短路行为,如果运算符左边的值已经可以确定整个布尔表达式的值,那么运算符右边的值将不再被求值,因此下面的表达式总是安全的:

    s != "" && s[0] == 'x'	// 其中 s[0] 操作如果应用于空字符串将会导致 panic 异常。
    

    1.3、字符串类型

    字符串是一种值类型,且值不可变,即创建某个文本后将无法再次修改这个文本的内容,更深入地讲,字符串是字节的定长数组。

    1.3.1、定义字符串

    可以使用双引号""来定义字符串,字符串中可以使用转义字符来实现换行、缩进等效果,常用的转义字符包括:\n:换行符、\r:回车符、\t:tab 键、\u 或 \U:Unicode 字符、\:反斜杠自身。
    例如:

    var str = "C语言中文网\nGo语言教程"
    

    字符串的内容(纯字节)可以通过标准索引法来获取,在方括号[]内写入索引,索引从 0 开始计数:

    • 字符串 str 的第 1 个字节:str[0]
    • 第 i 个字节:str[i - 1]
    • 最后 1 个字节:str[len(str)-1]

    需要注意的是,这种转换方案只对纯 ASCII 码的字符串有效。
    注意:获取字符串中某个字节的地址属于非法行为,例如 &str[i]。

    1.3.2、字符串拼接符“+”

    两个字符串 s1 和 s2 可以通过 s := s1 + s2 拼接在一起。将 s2 追加到 s1 尾部并生成一个新的字符串 s。

    可以通过下面的方式来对代码中多行的字符串进行拼接:

    str := "Beginning of the string " + "second part of the string"
    

    提示:因为编译器会在行尾自动补全分号,所以拼接字符串用的加号“+”必须放在第一行末尾。

    也可以使用“+=”来对字符串进行拼接:

    s := "hel" + "lo,"
    s += "world!"
    fmt.Println(s) //输出 “hello, world!”
    

    1.3.3、字符串实现基于 UTF-8 编码

    Go语言中字符串的内部实现使用 UTF-8 编码,通过 rune 类型,可以方便地对每个 UTF-8 字符进行访问。当然,Go语言也支持按照传统的 ASCII 码方式逐字符进行访问。

    1.3.4、定义多行字符串

    在Go语言中,使用双引号书写字符串的方式是字符串常见表达方式之一,被称为字符串字面量(string literal),这种双引号字面量不能跨行,如果想要在源码中嵌入一个多行字符串时,就必须使用`反引号,代码如下:
    在这里插入图片描述
    代码运行结果:
    在这里插入图片描述

    在 `间的所有代码均不会被编译器识别,而只是作为字符串的一部分。

    1.4、字符类型(byte和rune)

    1.4.1、概念

    字符串中的每一个元素叫做“字符”,在遍历或者单个获取字符串元素时可以获得字符。
    字符有以下两种:

    • 一种是 uint8 类型,或者叫 byte 型,代表了 ASCII 码的一个字符。
    • 另一种是 rune 类型,代表一个 UTF-8 字符,当需要处理中文、日文或者其他复合字符时,则需要用到 rune 类型。rune 类型等价于 int32 类型。

    下面的写法是等效的:

    var ch byte = 65var ch byte = '\x41'      // \x 总是紧跟着长度为 2 的 16 进制数
    

    另外一种可能的写法是 \后面紧跟着长度为 3 的八进制数,例如 \377。

    Go语言同样支持 Unicode(UTF-8),因此字符同样称为 Unicode 代码点或者 runes,并在内存中使用 int 来表示。在文档中,一般使用格式 U+hhhh 来表示,其中 h 表示一个 16 进制数。

    在书写 Unicode 字符时,需要在 16 进制数之前加上前缀\u或者\U。因为 Unicode 至少占用 2 个字节,所以我们使用 int16 或者 int 类型来表示。如果需要使用到 4 字节,则使用\u前缀,如果需要使用到 8 个字节,则使用\U前缀。

    var ch int = '\u0041'
    var ch2 int = '\u03B2'
    var ch3 int = '\U00101234'
    fmt.Printf("%d - %d - %d\n", ch, ch2, ch3) // integer: 65 - 946 - 1053236
    fmt.Printf("%c - %c - %c\n", ch, ch2, ch3) // character: A - β - r
    fmt.Printf("%X - %X - %X\n", ch, ch2, ch3) // UTF-8 bytes: 41 - 3B2 - 101234
    fmt.Printf("%U - %U - %U", ch, ch2, ch3)   // UTF-8 code point: U+0041 - U+03B2 - U+101234
    

    1.4.2、UTF-8 和 Unicode 的区别

    Unicode 与 ASCII 类似,都是一种字符集。

    字符集为每个字符分配一个唯一的 ID,我们使用到的所有字符在 Unicode 字符集中都有一个唯一的 ID,例如上面例子中的 a 在 Unicode 与 ASCII 中的编码都是 97。汉字“你”在 Unicode 中的编码为 20320,在不同国家的字符集中,字符所对应的 ID 也会不同。而无论任何情况下,Unicode 中的字符的 ID 都是不会变化的。

    UTF-8 是编码规则,将 Unicode 中字符的 ID 以某种方式进行编码,UTF-8 的是一种变长编码规则,从 1 到 4 个字节不等。编码规则如下:

    • 0xxxxxx 表示文字符号 0~127,兼容 ASCII 字符集。
    • 从 128 到 0x10ffff 表示其他字符。

    根据这个规则,拉丁文语系的字符编码一般情况下每个字符占用一个字节,而中文每个字符占用 3 个字节。

    广义的 Unicode 指的是一个标准,它定义了字符集及编码规则,即 Unicode 字符集和 UTF-8、UTF-16 编码等。

    2、类型转换

    2.1、类型转换的概念

    类型 B 的值 = 类型 B(类型 A 的值)
    

    在必要以及可行的情况下,一个类型的值可以被转换成另一种类型的值。由于Go语言不存在隐式类型转换,因此所有的类型转换都必须显式的声明:

    a := 5.0
    b := int(a)
    

    浮点数在转换为整型时,会将小数部分去掉,只保留整数部分。

    2.2、字符串和数值类型的相互转换

    开发时往往需要对一些常用的数据类型进行转换,如 string、int、int64、float 等数据类型之间的转换,Go语言中的 strconv 包为我们提供了字符串和基本数据类型之间的转换功能。strconv 包中常用的函数包括 Atoi()、Itia()、parse 系列函数、format 系列函数、append 系列函数等。

    2.2.1、string 与 int 类型之间的转换

    字符串和整型之间的转换是我们平时编程中使用的最多的,下面就来介绍一下具体的操作。

    • Itoa():整型转字符串

    Itoa() 函数用于将 int 类型数据转换为对应的字符串类型,函数签名如下func Itoa(i int) string,如:

    func main() {
        num := 100
        str := strconv.Itoa(num)
        fmt.Printf("type:%T value:%#v\n", str, str) // type:string value:"100"
    }
    
    • Atoi():字符串转整型

    Atoi() 函数用于将字符串类型的整数转换为 int 类型,函数签名func Atoi(s string) (i int, err error)。通过函数签名可以看出 Atoi() 函数有两个返回值,i 为转换成功的整型,err 在转换成功是为空转换失败时为相应的错误信息,如:

    func main() {
        str1 := "110"
        str2 := "s100"
        num1, err := strconv.Atoi(str1)
        if err != nil {
            fmt.Printf("%v 转换失败!", str1)
        } else {
            fmt.Printf("type:%T value:%#v\n", num1, num1)
        }
        num2, err := strconv.Atoi(str2)
        if err != nil {
            fmt.Printf("%v 转换失败!", str2)
        } else {
            fmt.Printf("type:%T value:%#v\n", num2, num2)
        }
    }
    

    结果:

    type:int value:110
    s100 转换失败!
    

    2.2.2、Parse 系列函数

    Parse 系列函数用于将字符串转换为指定类型的值,其中包括 ParseBool()、ParseFloat()、ParseInt()、ParseUint()。

    2.2.2.1、ParseBool()

    ParseBool() 函数用于将字符串转换为 bool 类型的值,它只能接受 1、0、t、f、T、F、true、false、True、False、TRUE、FALSE,其它的值均返回错误,函数签名:func ParseBool(str string) (value bool, err error)
    示例如下:

    func main() {
        str1 := "110"
        boo1, err := strconv.ParseBool(str1)
        if err != nil {
            fmt.Printf("str1: %v\n", err)
        } else {
            fmt.Println(boo1)
        }
        str2 := "t"
        boo2, err := strconv.ParseBool(str2)
        if err != nil {
            fmt.Printf("str2: %v\n", err)
        } else {
            fmt.Println(boo2)
        }
    }
    

    结果如下:

    str1: strconv.ParseBool: parsing "110": invalid syntax
    true
    

    2.2.2.2、ParseInt()

    ParseInt() 函数用于返回字符串表示的整数值(可以包含正负号),函数签名:func ParseInt(s string, base int, bitSize int) (i int64, err error)。参数说明:

    • base 指定进制,取值范围是 2 到 36。如果 base 为 0,则会从字符串前置判断,“0x”是 16 进制,“0”是 8 进制,否则是 10 进制。
    • bitSize 指定结果必须能无溢出赋值的整数类型,0、8、16、32、64 分别代表 int、int8、int16、int32、int64。
    • 返回的 err 是 *NumErr 类型的,如果语法有误,err.Error = ErrSyntax,如果结果超出类型范围 err.Error = ErrRange。

    示例代码如下:

    func main() {
        str := "-11"
        num, err := strconv.ParseInt(str, 10, 0)
        if err != nil {
            fmt.Println(err)
        } else {
            fmt.Println(num)
        }
    }
    

    运行结果如下:

    -11
    

    2.2.2.3、ParseUnit()

    ParseUint() 函数的功能类似于 ParseInt() 函数,但 ParseUint() 函数不接受正负号,用于无符号整型,函数签名:func ParseUint(s string, base int, bitSize int) (n uint64, err error)。示例代码如下:

    func main() {
        str := "11"
        num, err := strconv.ParseUint(str, 10, 0)
        if err != nil {
            fmt.Println(err)
        } else {
            fmt.Println(num)
        }
    }
    

    运行结果如下:

    11
    

    2.2.2.4、ParseFloat()

    ParseFloat() 函数用于将一个表示浮点数的字符串转换为 float 类型,函数签名: func ParseFloat(s string, bitSize int) (f float64, err error)。参数说明:

    • 如果 s 合乎语法规则,函数会返回最为接近 s 表示值的一个浮点数(使用 IEEE754 规范舍入)。
    • bitSize 指定了返回值的类型,32 表示 float32,64 表示 float64;
    • 返回值 err 是 *NumErr 类型的,如果语法有误 err.Error=ErrSyntax,如果返回值超出表示范围,返回值 f 为 ±Inf,err.Error= ErrRange。

    示例代码如下:

    func main() {
        str := "3.1415926"
        num, err := strconv.ParseFloat(str, 64)
        if err != nil {
            fmt.Println(err)
        } else {
            fmt.Println(num)
        }
    }
    

    运行结果如下:

    3.1415926
    

    Parse 系列函数都有两个返回值,第一个返回值是转换后的值,第二个返回值为转化失败的错误信息。

    2.2.3、Format 系列函数

    Format 系列函数实现了将给定类型数据格式化为字符串类型的功能,其中包括 FormatBool()、FormatInt()、FormatUint()、FormatFloat()。

    2.2.3.1、FormatBool()

    FormatBool() 函数可以一个 bool 类型的值转换为对应的字符串类型,函数签名:func FormatBool(b bool) string。示例代码如下:

    func main() {
        num := true
        str := strconv.FormatBool(num)
        fmt.Printf("type:%T,value:%v\n ", str, str)
    }
    

    运行结果如下:

    type:string,value:true
    

    2.2.3.2、FormatInt()

    FormatInt() 函数用于将整型数据转换成指定进制并以字符串的形式返回,函数签名: func FormatInt(i int64, base int) string。其中,参数 i 必须是 int64 类型,参数 base 必须在 2 到 36 之间,返回结果中会使用小写字母“a”到“z”表示大于 10 的数字。示例代码如下:

    func main() {
        var num int64 = 100
        str := strconv.FormatInt(num, 16)
        fmt.Printf("type:%T,value:%v\n ", str, str)
    }
    

    运行结果如下:

    type:string,value:64
    

    2.2.3.3、FormatUint()

    FormatUint() 函数与 FormatInt() 函数的功能类似,但是参数 i 必须是无符号的 uint64 类型,函数签名: func FormatUint(i uint64, base int) string。示例代码如下:

    func main() {
        var num uint64 = 110
        str := strconv.FormatUint(num, 16)
        fmt.Printf("type:%T,value:%v\n ", str, str)
    }
    

    运行结果如下:

    type:string,value:6e
    

    2.2.3.4、FormatFloat()

    FormatFloat() 函数用于将浮点数转换为字符串类型,函数签名:func FormatFloat(f float64, fmt byte, prec, bitSize int) string。参数说明:

    • bitSize 表示参数 f 的来源类型(32 表示 float32、64 表示 float64),会据此进行舍入。
    • fmt 表示格式,可以设置为“f”表示 -ddd.dddd、“b”表示 -ddddp±ddd,指数为二进制、“e”表示 -d.dddde±dd 十进制指数、“E”表示 -d.ddddE±dd 十进制指数、“g”表示指数很大时用“e”格式,否则“f”格式、“G”表示指数很大时用“E”格式,否则“f”格式。
    • prec 控制精度(排除指数部分):当参数 fmt 为“f”、“e”、“E”时,它表示小数点后的数字个数;当参数 fmt 为“g”、“G”时,它控制总的数字个数。如果 prec 为 -1,则代表使用最少数量的、但又必需的数字来表示 f。

    示例代码如下:

    func main() {
        var num float64 = 3.1415926
        str := strconv.FormatFloat(num, 'E', -1, 64)
        fmt.Printf("type:%T,value:%v\n ", str, str)
    }
    

    运行结果如下:

    type:string,value:3.1415926E+00
    

    2.2.4、Append 系列函数

    Append 系列函数用于将指定类型转换成字符串后追加到一个切片中,其中包含 AppendBool()、AppendFloat()、AppendInt()、AppendUint()。

    Append 系列函数和 Format 系列函数的使用方法类似,只不过是将转换后的结果追加到一个切片中。

    示例代码如下:

    package main
    import (
        "fmt"
        "strconv"
    )
    func main() {
        // 声明一个slice
        b10 := []byte("int (base 10):")
      
        // 将转换为10进制的string,追加到slice中
        b10 = strconv.AppendInt(b10, -42, 10)
        fmt.Println(string(b10))
        b16 := []byte("int (base 16):")
        b16 = strconv.AppendInt(b16, -42, 16)
        fmt.Println(string(b16))
    }
    

    运行结果如下:

    int (base 10):-42
    int (base 16):-2a
    

    3、运算符的优先级

    运算符是用来在程序运行时执行数学或逻辑运算的,在Go语言中,一个表达式可以包含多个运算符,当表达式中存在多个运算符时,就会遇到优先级的问题,此时应该先处理哪个运算符呢?这个就由Go语言运算符的优先级来决定的。
    比如对于下面的表达式:

    var a, b, c int = 16, 4, 2
    d := a + b*c
    

    对于表达式a + b * c,如果按照数学规则推导,应该先计算乘法,再计算加法;b * c的结果为 8,a + 8的结果为 24,所以 d 最终的值也是 24。实际上Go语言也是这样处理的,先计算乘法再计算加法,和数据中的规则一样,读者可以亲自验证一下。

    先计算乘法后计算加法,说明乘法运算符的优先级比加法运算符的优先级高。所谓优先级,就是当多个运算符出现在同一个表达式中时,先执行哪个运算符。

    Go语言有几十种运算符,被分成十几个级别,有的运算符优先级不同,有的运算符优先级相同,请看下表。

    优先级 分类 运算符 结合性
    1 逗号运算符 , 从左到右
    2 赋值运算符 =、+=、-=、*=、/=、 %=、 >=、 <<=、&=、^=、|= 从右到左
    3 逻辑或 || 从左到右
    4 逻辑与 && 从左到右
    5 按位或 | 从左到右
    6 按位异或 ^ 从左到右
    7 按位与 & 从左到右
    8 相等/不等 ==、!= 从左到右
    9 关系运算符 <、<=、>、>= 从左到右
    1 位移运算符 <<、>> 从左到右
    1 加法/减法 +、- 从左到右
    1 乘法/除法/取余 *(乘号)、/、% 从左到右
    1 单目运算符 !、*(指针)、& 、++、–、+(正号)、-(负号) 从右到左
    1 后缀运算符 ( )、[ ]、-> 从左到右

    注意:优先级值越大,表示优先级越高。

    一下子记住所有运算符的优先级并不容易,还好Go语言中大部分运算符的优先级和数学中是一样的,大家在以后的编程过程中也会逐渐熟悉起来。如果实在搞不清,可以加括号。

    展开全文
  • '中文简体与繁体的互换 Private Declare Function LCMapString Lib "kernel32" Alias "LCMapStringA" (ByVal Locale As Long, _ ByVal dwMapFlags As Long, ByVal lpSrcStr As String, ByVal cchSrc As Long, ByVal ...
  • python六大数据类型详解

    万次阅读 多人点赞 2019-10-13 21:07:18
    史上最全数据类型详解,详细介绍了Python3 中六个标准的数据类型:Number(数值)、String(字符串)、List(列表)、Tuple(元组)、Set(集合)、Dictionary(字典)。六大数据类型的方法和常规操作。
  • java数据类型与运算符

    千次阅读 2014-04-11 17:00:38
    本文讲述java数据类型和java运算符,java数据类型包括8种基本数据类型和引用数据类型,不同类型数据间有转换机制;本文还描述了java众多运算符及一些对应使用注意事项和运算符优先级。 java数据类型 Java是强数据...
  • 作者:Matt Hansen,Aaron Blasdel和Camilo Buscaron (机器翻译) ...机器人操作系统(ROS)是用于机器人开发的开源软件框架,包括中间件,驱动程序,库,工具以及机器人常用的算法。AWS RoboMaker和许多其他与A
  • 一、值,类型和运算符 原文:Values, Types, and Operators 译者:飞龙 协议:CC BY-NC-SA 4.0 自豪地采用谷歌翻译 部分参考了《JavaScript 编程精解(第 2 版)》 在机器的表面之下,程序在运转...
  • 《实用多媒体技术》课程标准

    千次阅读 2006-07-18 09:02:00
    纯原创,如果您需要引用或参考,请注明出处:http://blog.csdn.net/softwave《实用多媒体技术》课程标准(本标准根据人才培养工作水平评估标准编写)目录第一部分 前言 3一、课程性质和任务 3二、基本理念 3三、...
  • IOT语义互操作性之标准与开源

    千次阅读 2018-02-20 00:00:00
    UnifiedPOS (UPOS):UPOS 是一个全球采用的互操作性标准, 包括30多个销售点(POS)周边设备类(例如, 现金抽屉、收据打印机等)的 uml 定义的数据模型。 这些数据模型可以在 UPOS 控制和服务层中互操作。 开放连接基金会...
  • 软件工程的国家标准(总结)

    万次阅读 2016-04-12 15:36:29
    软件工程国家标准分为六大类 1、 专业基础标准 2、 过程标准 3、 质量标准 4、 技术与管理标准 5、 工具与方法标准 6、 数据标准   大纲将软件工程标准分为4大类: 1、 基础标准 软件...
  • julia:类型

    千次阅读 2018-08-29 21:35:09
    通常,我们把程序语言中的类型系统划分成两类:静态类型和动态类型。对于静态类型系统,在程序运行之前,我们就知道每一个表达式的类型。而对于动态类型系统,我们只有通过运行那个程序,得到表达式具体的值,才能...
  • DES 数据加密标准 结构详解

    千次阅读 2017-09-26 02:01:08
    Data Encryption Standard,又称数据加密标准,是一种对称加密算法,也是密码学摆脱古典流加密后最简单的一种块加密算法。由于香农与1949年提出“完善保密性”,该标准要求密钥长度不短于明文长度,实际操作难以达到...
  • 数据属性类型

    千次阅读 2019-03-05 14:51:53
    数据集由数据对象组成,一个数据对象代表一个实体。数据对象又称样本、实例、...属性有不同类型:标称属性(nominal attribute)、二元属性(binary attribute)、序数属性(ordinal attribute)、 数值属性(num...
  • DICOM标准概要

    千次阅读 2019-08-14 16:27:40
    1.DICOM标准英文文档https://www.dicomstandard.org/current/...3.DICOM标准文件内容概要 DICOM(Digital Imaging and Communications in Medicine)医学数字成像和通信 重点在2——9 第一部分:引言与概述,简要...
  • C#中的数据类型

    千次阅读 2016-05-30 11:25:31
    类型和引用类型都可以为泛型类型 (generic type),泛型类型采用一个或多个类型参数。类型参数可以指定值类型和引用类型。 type: value-type reference-type type-parameter 第三种类型是指针,只能用在不...
  • 数据规范化(标准化)

    万次阅读 2018-01-24 16:57:36
    在数据预处理时,这两个术语可以互换使用。(不考虑标准化在统计学中有特定的含义)。  下面所有的规范化操作都是针对一个特征向量(dataFrame中的一个colum)来操作的。  首先举一个例子: //MaxAbsScaler例子...
  • C语言编码风格和标准

    千次阅读 2013-12-18 10:05:40
    C++使用编译器相关的后缀约定,包括.c,..c,.cc,.c.c以及.C。由于大多C代码也是C++代码,因此这里并没有一个明确的方案。 此外,我们一般约定使用"Makefile"(而不是"makefile")作为make(对于那些支持make的...
  • 运算符和类型强制转换

    千次阅读 2011-01-05 18:53:00
    第6章  运算符和类型强制转换 前几章介绍了使用C#编写程序所需要的大部分知识。本章将首先讨论基本语言... 重载标准的运算符,以支持对定制类型的操作 ● 给定制类型添加强制转换运算符,以支持
  • 研发部软件开发国家标准

    千次阅读 2019-10-07 23:49:31
    软件工程国家标准分为六大类 1、 专业基础标准 2、 过程标准 3、 质量标准 4、 技术与管理标准 5、 工具与方法标准 6、 数据标准 大纲将软件工程标准分为4大类: 1、 基础标准软件工程术语信息处理 数据...
  • SQLite3的数据类型

    千次阅读 2013-05-31 17:25:43
    大多数 SQL 数据库引擎 (据我们所知,除 SQLite 之外的所有 SQL 数据库引擎)都使用严格的静态类型。使用静态类型,值的类型便由它的容器 -- 存储值的特定的列 -- 来决定。 SQLite 使用更通用的动态类型系统。在 ...
  • 标准C++中的vector用法

    2016-01-25 19:18:57
    STL是C++标准的组成部分,它提供了一组表示容器、迭代器、函数对象和算法的模板。 容器:是一个与数组类似的单元,可以存若干个值。STL容器是同质的,即存储的值的类型相同; 算法:是完成特定任务的处方; 迭代器:...
  • STEP 标准基础概念-刘亚龙

    千次阅读 2019-05-15 10:26:28
    STEP(Standard for the Exchange of Product Model Data-产品模型数据交互规范)[1]标准是国际标准化组织制定的描述整个产品生命周期内产品信息的标准,STEP标准是一个正在完善中的“产品数据模型交换标准”。...
  • 数字图像的基本类型

    2019-09-16 21:20:29
    数字图像的基本类型 本文讲解10种图像文件的类型和相应的扩展名,主要参考: https://blog.hubspot.com/insiders/different-types-of-image-files. https://www.jianshu.com/p/4d8cace82028. ... Vecto...
  • C语言标准函数库(二)

    千次阅读 2013-07-02 17:29:02
    函数名: geninterrupt 功 能: 产生一个软中断 用 法: void geninterrupt(int intr_num); 84 程序例: #include #include /* function prototype */ void writechar(char ch);...clr
  • C++中的字符串类型及相互转化

    千次阅读 2013-03-28 16:20:23
      1、字符(串)表示分类  C++提供了两种字符串的表示形式,即C风格的字符串和标准字符串。 C++引入的是string 类类型,但实际上在许多程序的情形中我们有必要理解和使用...总共包括以下几种类型:  a.char  b.
  • 发布:mdxy-dxy 字体:[增加 减小] 类型:转载 字符是各种文字和符号的总称,包括各国家文字、标点符号、图形符号、数字等。 字符集是多个字符的集合,字符集种类较多,每个字符集包含的字符个数不同,常见字符集...
  • 型 号:VK2C21 / 品 牌:VINTEK/元泰封装形式:NSOP16 SOP20 SOP24 SOP28 概述:VK2C21 是一款...VK2C21 的软件配置特性使得它 适用于多种 LCD 应用,包括 LCD 模块和显示子 系统。VK2C2X系列为I2C介面、RAM ma...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,792
精华内容 7,516
关键字:

互换的标准类型包括