精华内容
下载资源
问答
  • 关于c语言的字符常量

    2021-01-04 16:40:57
    逝者如斯夫,不舍昼夜”## 在c语言中,字符常量有以下特点: 1.字符常量只能用单引号括起来,也就是说...例:下列常量中合法的字符常量是(B) A.A B.‘\t’ C.‘65’ D.“A” 希望对大家有帮助呀 List item ...

    逝者如斯夫,不舍昼夜”##
    在这里插入图片描述
    在c语言中,字符常量有以下特点:
    1.字符常量只能用单引号括起来,也就是说不能用双引号或其它括号。
    2.字符常量只能是单个字符,不能为字符串。
    3.字符可以是字符集中的任意一个(ASCII)表中。
    4.在运算时‘3’的值就变成了其在ASCII表中对应的数值51(其他数字同理)。
    在这里插入图片描述
    例:下列常量中合法的字符常量是(B)
    A.A
    B.‘\t’
    C.‘65’
    D.“A”
    希望对大家有帮助呀

    List item

    在这里插入图片描述

    展开全文
  • 当定义的变量为单个字符是,必须外面是单引号,字符用双引号引起。 附:转载OGNL表达式相关的知识点: OGNL的全称是Object Graph Navigation Language(对象图导航语言),它是一种强大的表达式语言,让你...

    具体记录如下:

    <s:set name="fieldType" value="'condition'"></s:set>
    <s:set name="countryID" value="'CHN'"></s:set>
    <s:set name="corpCenter" value="#session.opType.corpCenter"></s:set>
    <s:set name="corpID" value="#session.opType.corpID"></s:set>
    <s:set name="corpType" value="#session.opType.corpType"></s:set>
    <s:set name="agentID" value=""></s:set>
    <s:set name="city" value=""></s:set>
    <s:set name="agentType" value='"A"'></s:set>
    注意上面红色部分的标识。当定义的变量为单个字符是,必须外面是单引号,字符用双引号引起。

    <s:action name="ReportBeanListAction" id="reportBeanSkyechoAgentListAction">
    <s:param name="agentID"><s:property value="agentID" /></s:param>
    <s:param name="city"><s:property value="city" /></s:param>
    <s:param name="corpID"><s:property value="corpID" /></s:param>
    <s:param name="corpCenter"><s:property value="corpCenter" /></s:param>
    <s:param name="agentType"><s:property value="agentType" /></s:param>
    </s:action>

    附:转载OGNL表达式相关的知识点:

    OGNL的全称是Object Graph Navigation Language(对象图导航语言),它是一种强大的表达式语言,让你通过简单一致的表达式语法来读取和设置Java对象的属性值,调用对象的方法,遍历整个对象的结构图,实现字段类型转换等功能。

    为什么使用OGNL
    相对于其它的表达式语言,OGNL的功能更为强大,它提供了很多高级而必需的特性,例如强大的类型转换功能、静态或实例方法的执行、跨集合投影,以及动态lambda表达式定义等。
    OGNL基础
    OGNL表达式的计算都是围绕OGNL上下文来进行的,OGNL上下文实际上就是一个Map对象,由ognl.OgnlContext类(实现了 java.util.Map接口)来表示。OGNL上下文可以包含一个或多个JavaBean对象,在这些对象中有一个是特殊的,这个对象就是上下文的根 (root)对象。如果在写表达式的时候,没有指定使用上下文中的哪一个对象,那么根对象将被假定为表达式所依据的对象。
    在OGNL上下文中,只能有一个根对象,如果你访问根对象,那么在写表达式的时候,直接写对象的属性就可以了;否则,你需要使用“#key”前缀,例如表达式#namager.name。
    OGNL表达式
    OGNL表达式的基础单元就是导航链,通常简称为链(chain)。最简单的链由下列部分组成:
    1、属性名:如name和manager.name;
    2、方法调用:如manager.hashCode(),返回manager对象的散列码;
    3、数组索引:如emals[0],返回当前对象的邮件列表中的第一个邮件地址。
    所有OGNL表达式的计算都是在当前对象的上下文中,一个链简单地使用链中先前链接的结果作为下一步计算的当前对象。我们看如下所示的链:
    name.toCharArray()[0].numericValue.toString()
    这个表达式按照下列的步骤进行计算:
    1、获取根对象的name属性;
    2、在String结果上调用toCharArray()方法;
    3、从char数组中提取第一个字符;
    4、从提取的字符对象上行到numericValue属性(这个字符被表示为Character对象,Character类有一个getNumericValue()方法);
    5、在Integer对象结果上调用toString()方法。
    这个表达式最终结果是最后返回的toString()方法调用返回的字符串。
    常量
    OGNL支持的所有常量类型:
    1、字符串常量:
    以单引号或双引号括起来的字符串。如”hello”,’hello’。
    不过要注意的是,如果是单个字符的字符串常量,必须使用双引号。
    2、字符常量:
    以单引号括起来的字符。如’a'。
    3、数值常量:
    除了Java中的int、long、float和double外,OGNL还让你使用“b”或“B”后缀指定BigDecimal常量,用“h”“H”后缀指定BigInteger常量。
    4、布尔常量:
    true和false。
    5、null常量。
    操作符
    OGNL除了支持所有的Java操作符外,还支持以下几种:
    1、逗号,
    与C语言中的逗号操作符类似。
    2、花括号{}
    用于创建列表,元素之间用逗号分隔。
    3、in和not in
    用于判断一个值是否在集合中。
    访问JavaBean的属性
    假如有一个employee对象作为OGNL上下文的根对象,那对于下面的表达式:
    1、name
    对应的java代码是employee.getName();
    2、address.country
    对应的java代码是employee.getAddress().getCountry();
    访问静态方法和静态字段
    @class@method(args)     //调用静态方法
    @class@field         //调用静态字段
    其中class必须给出完整的类名(包括包名),如果省略class,那么默认使用的类是java.util.Math,如:
    @@min(5,3)
    @@max(5,3)
    @@PI
    索引访问
    OGNL支持多种索引方式的访问。
    1、数组和列表索引
    在OGNL中,数组和列表可以大致看成是一样的。
    如:array[0]、list[0]。表达式:{’zhangsan’,'lisi’,'wangwu’}[1]等。
    2、JavaBean的索引属性
    要使用索引属性,需要提供两对setter和getter方法,一对用于数组,一对用于数组中的元素。
    如:有一个索引属性interest,它的getter和setter如下
    public String[] interest;
    public String[] getInterest(){ return interest;}
    public void setInterest(String[] interest){ this.interest=interest;}
    public String getInterest(int i){ return interest[i]}
    public void setInterest(int i, String newInterest){ interest[i]=newInterest;}
    对于表达式interest[2],OGNL可以正确解释这个表达式,调用getInterest(2)方法。如果是设置的情况下,会调用setInterest(2,value)方法。
    3、OGNL对象的索引属性
    JavaBean的索引属性只能使用整型作为索引,OGNL扩展了索引属性的概念,可以使用任意的对象来作为索引。
    对集合进行操作
    1、创建集合:
    创建列表
    使用花括号将元素包含起来,元素之间使用逗号分隔。如{’zhangsan’,'lisi’,'wangwu’}
    创建数组
    OGNL中创建数组与Java语言中创建数组类似。
    创建Map
    Map使用特殊的语法来创建 #{”key”:value, ……}
    如果想指定创建的Map类型,可以在左花括号前指定Map实现类的类名。如:
    #@java.util.LinkedHashMap@{”key”:”value”,….}
    Map通过key来访问,如map["key"]或map.key。
    2、投影
    OGNL提供了一种简单的方式在一个集合中对每一个元素闻调用相同的方法,或者抽取相同的属性,并将结果保存为一个新的集合,称之为投影。
    假如employees是一个包含了employee对象的列表,那么
    #employees.{name}将返回所有雇员的名字的列表。
    在投影期间,使用#this变量来引用迭代中的当前元素。
    如:objects.{#this instanceof String? #this: #this.toString()}
    3、选择
    OGNL提供了一种简单的方式来使用表达式从集合中选择某些元素,并将结果保存到新的集合中,称为选择。
    如#employees.{?#this.salary>3000}
    将返回薪水大于3000的所有雇员的列表。
    #employees.{^#this.salary>3000}
    将返回第一个薪水大于3000的雇员的列表。
    #employees.{$#this.salary>3000}
    将返回最后一个薪水大于3000的雇员的列表。
    lambda表达式
    lambda表达式的语法是:   :[...]。OGNL中的lambda表达式只能使用一个参数,这个参数通过#this引用。
    如:
    #fact= :[ #this<=1 ? 1 : #this* #fact ( #this-1) ], #fact(30)
    #fib= :[#this==0 ? 0 : #this==1 ? 1 : #fib(#this-2)+#fib(#this-1)], #fib(11)

    OGNL的全称是Object Graph Navigation Language(对象图导航语言),它是一种强大的表达式语言,让你通过简单一致的表达式语法来读取和设置Java对象的属性值,调用对象的方法,遍历整个对象的结构图,实现字段类型转换等功能。

    展开全文
  •  在VS测试中发现,字符常量区(只读数据区)在编译时候与静态数据区放在了一起。因此在静态数据区的几种类型没有独立的地址区域,都是按照定义的时间顺序进行分配。而动态内存区不同,堆和栈有独立的地址区域,具体...

    自己总结一下关于内存分区的基础知识:

            先上图:


        在VS测试中发现,字符常量区(只读数据区)在编译时候与静态数据区放在了一起。因此在静态数据区的几种类型没有独立的地址区域,都是按照定义的时间顺序进行分配。而动态内存区不同,堆和栈有独立的地址区域,具体介绍可以看下文。


    1、 栈区(stack sagment):由编译器自动分配释放,存放函数的参数的值,局部变量的值等。在Windows下,栈是高向低地址扩展的数据结构,是一块连续的内存的区 域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是2M(也有的是1M,总之是一个编译时就确定的常数), 如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。


    2、堆区(heap sagment) : 一般由程序员分配释放,若程序员不释放,程序结束时可能由系统回收 。它与数据结构中的堆是两回事。堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表 的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。

    3、全局区(静态区)(data sagment):全局变量和静态变量的存储区域是在一起的,程序结束后由系统释放。数据区的大小由系统限定,一般很大。

    4、文字常量区:常量字符串就是放在这里的, 程序结束后由系统释放。

    5、程序代码区:存放函数体的二进制代码。


    个人的测试代码:

    		#include <stdio.h>
    		#include <malloc.h>
    
    		static int s1=0,s2=0,s3=0;    //静态变量 放在静态区
    		int g1=0,g2=0,g3=0;           //全局变量 放在静态区
    
    		void main()
    		{
    			static int s4=0,s5=0,s6=0;           //静态变量
    			int a1=0,a2=0,a3=0;             //局部变量 放在栈区
    			char c1[] = "aabb";            //局部变量 放在栈区
    			char *c2 = "aabb";             //字符常量 放在静态区
    			char *m1 = (char *)malloc(1);  //		 堆区
    			char *m2 = (char *)malloc(1);  //		 堆区
    			char *m3 = (char *)malloc(1);  //		 堆区
    			printf("动态数据区\n");
    			printf(" a1\n a2\n a3\n",&a1,&a2,&a3);
    			printf(" c1\n",c1);
    			printf(" m1\n m2\n m3\n",&m1,&m2,&m3);
    
    			printf("静态数据区\n");
    			printf(" s1\n s2\n s3\n",&s1,&s2,&s3);
    			printf(" g1\n g2\n g3\n",&g1,&g2,&g3);
    			printf(" s4\n s5\n s6\n",&s4,&s5,&s6);
    			printf(" c2\n",c2);
    		}
    


    了解一下 C 语言的变量是如何在内存分部的。C 语言有全局变量(Global)、本地变量(Local),静态变量(Static)、寄存器变量(Regeister)。每种变量都有不同的分配方式。先来看下面这段代码:
    #include <stdio.h>
    
    int g1=0, g2=0, g3=0;
    
    int main() 
    { 
    static int s1=0, s2=0, s3=0; 
    int v1=0, v2=0, v3=0;
    
    //打印出各个变量的内存地址
    
    printf("0x%08x\n",&v1); //打印各本地变量的内存地址 
    printf("0x%08x\n",&v2); 
    printf("0x%08x\n\n",&v3); 
    printf("0x%08x\n",&g1); //打印各全局变量的内存地址 
    printf("0x%08x\n",&g2); 
    printf("0x%08x\n\n",&g3); 
    printf("0x%08x\n",&s1); //打印各静态变量的内存地址 
    printf("0x%08x\n",&s2); 
    printf("0x%08x\n\n",&s3); 
    return 0; 
    }
    
    编译后的执行结果是:
    
    0x0012ff78 
    0x0012ff7c 
    0x0012ff80
    
    0x004068d0 
    0x004068d4 
    0x004068d8
    
    0x004068dc 
    0x004068e0 
    0x004068e4

    输 出的结果就是变量的内存地址。其中v1,v2,v3是本地变量,g1,g2,g3是全局变量,s1,s2,s3是静态变量。你可以看到这些变量在内存是连 续分布的,但是本地变量和全局变量分配的内存地址差了十万八千里,而全局变量和静态变量分配的内存是连续的。这是因为本地变量和全局/静态变量是分配在不 同类型的内存区域中的结果。对于一个进程的内存空间而言,可以在逻辑上分成3个部份:代码区,静态数据区和动态数据区。动态数据区一般就是“堆栈”。“栈 (stack)”和“堆(heap)”是两种不同的动态数据区,栈是一种线性结构,堆是一种链式结构。进程的每个线程都有私有的“栈”,所以每个线程虽然 代码一样,但本地变量的数据都是互不干扰。一个堆栈可以通过“基地址”和“栈顶”地址来描述。全局变量和静态变量分配在静态数据区,本地变量分配在动态数 据区,即堆栈中。程序通过堆栈的基地址和偏移量来访问本地变量。


    ├———————┤低端内存区域 
    │ …… │ 
    ├———————┤ 
    │ 动态数据区 │ 
    ├———————┤ 
    │ …… │ 
    ├———————┤ 
    │ 代码区 │ 
    ├———————┤ 
    │ 静态数据区 │ 
    ├———————┤ 
    │ …… │ 
    ├———————┤高端内存区域


    堆 栈是一个先进后出的数据结构,栈顶地址总是小于等于栈的基地址。我们可以先了解一下函数调用的过程,以便对堆栈在程序中的作用有更深入的了解。不同的语言 有不同的函数调用规定,这些因素有参数的压入规则和堆栈的平衡。windows API的调用规则和ANSI C的函数调用规则是不一样的,前者由被调函 数调整堆栈,后者由调用者调整堆栈。两者通过“__stdcall”和“__cdecl”前缀区分。先看下面这段代码:

    #include <stdio.h>
    
    void __stdcall func(int param1,int param2,int param3) 
    { 
    int var1=param1; 
    int var2=param2; 
    int var3=param3; 
    printf("0x%08x\n",&m1); //打印出各个变量的内存地址 
    printf("0x%08x\n",&m2); 
    printf("0x%08x\n\n",&m3); 
    printf("0x%08x\n",&var1); 
    printf("0x%08x\n",&var2); 
    printf("0x%08x\n\n",&var3); 
    return; 
    }
    
    int main() 
    { 
    func(1,2,3); 
    return 0; 
    }
    
    编译后的执行结果是:
    
    0x0012ff78 
    0x0012ff7c 
    0x0012ff80
    
    0x0012ff68 
    0x0012ff6c 
    0x0012ff70



    ├———————┤<—函数执行时的栈顶(ESP)、低端内存区域 
    │ …… │ 
    ├———————┤ 
    │ var 1 │ 
    ├———————┤ 
    │ var 2 │ 
    ├———————┤ 
    │ var 3 │ 
    ├———————┤ 
    │ RET │ 
    ├———————┤<—“__cdecl”函数返回后的栈顶(ESP) 
    │ parameter 1 │ 
    ├———————┤ 
    │ parameter 2 │ 
    ├———————┤ 
    │ parameter 3 │ 
    ├———————┤<—“__stdcall”函数返回后的栈顶(ESP) 
    │ …… │ 
    ├———————┤<—栈底(基地址 EBP)、高端内存区域


    上 图就是函数调用过程中堆栈的样子了。首先,三个参数以从又到左的次序压入堆栈,先压“param3”,再压“param2”,最后压入“param1”; 然后压入函数的返回地址(RET),接着跳转到函数地址接着执行(这里要补充一点,介绍UNIX下的缓冲溢出原理的文章中都提到在压入RET后,继续压入 当前EBP,然后用当前ESP代替EBP。然而,有一篇介绍windows下函数调用的文章中说,在windows下的函数调用也有这一步骤,但根据我的 实际调试,并未发现这一步,这还可以从param3和var1之间只有4字节的间隙这点看出来);第三步,将栈顶(ESP)减去一个数,为本地变量分配内 存空间,上例中是减去12字节(ESP=ESP-3*4,每个int变量占用4个字节);接着就初始化本地变量的内存空间。由于“__stdcall”调 用由被调函数调整堆栈,所以在函数返回前要恢复堆栈,先回收本地变量占用的内存(ESP=ESP+3*4),然后取出返回地址,填入EIP寄存器,回收先 前压入参数占用的内存(ESP=ESP+3*4),继续执行调用者的代码。参见下列汇编代码:

    ;--------------func 函数的汇编代码-------------------

    :00401000 83EC0C sub esp, 0000000C //创建本地变量的内存空间 
    :00401003 8B442410 mov eax, dword ptr [esp+10] 
    :00401007 8B4C2414 mov ecx, dword ptr [esp+14] 
    :0040100B 8B542418 mov edx, dword ptr [esp+18] 
    :0040100F 89442400 mov dword ptr [esp], eax 
    :00401013 8D442410 lea eax, dword ptr [esp+10] 
    :00401017 894C2404 mov dword ptr [esp+04], ecx

    ……………………(省略若干代码)

    :00401075 83C43C add esp, 0000003C ;恢复堆栈,回收本地变量的内存空间 
    :00401078 C3 ret 000C ;函数返回,恢复参数占用的内存空间 
    ;如果是“__cdecl”的话,这里是“ret”,堆栈将由调用者恢复

    ;-------------------函数结束-------------------------


    ;--------------主程序调用func函数的代码--------------

    :00401080 6A03 push 00000003 //压入参数param3 
    :00401082 6A02 push 00000002 //压入参数param2 
    :00401084 6A01 push 00000001 //压入参数param1 
    :00401086 E875FFFFFF call 00401000 //调用func函数 
    ;如果是“__cdecl”的话,将在这里恢复堆栈,“add esp, 0000000C”

    聪明的读者看到这里,差不多就明白缓冲溢出的原理了。先来看下面的代码:

    #include <stdio.h> 
    #include <string.h>
    
    void __stdcall func() 
    { 
    char lpBuff[8]="\0"; 
    strcat(lpBuff,"AAAAAAAAAAA"); 
    return; 
    }
    
    int main() 
    { 
    func(); 
    return 0; 
    }


    编 译后执行一下回怎么样?哈,“"0x00414141"指令引用的"0x00000000"内存。该内存不能为"read"。”,“非法操作”喽! "41"就是"A"的16进制的ASCII码了,那明显就是strcat这句出的问题了。"lpBuff"的大小只有8字节,算进结尾的\0,那 strcat最多只能写入7个"A",但程序实际写入了11个"A"外加1个\0。再来看看上面那幅图,多出来的4个字节正好覆盖了RET的所在的内存空 间,导致函数返回到一个错误的内存地址,执行了错误的指令。如果能精心构造这个字符串,使它分成三部分,前一部份仅仅是填充的无意义数据以达到溢出的目 的,接着是一个覆盖RET的数据,紧接着是一段shellcode,那只要着个RET地址能指向这段shellcode的第一个指令,那函数返回时就能执 行shellcode了。但是软件的不同版本和不同的运行环境都可能影响这段shellcode在内存中的位置,那么要构造这个RET是十分困难的。一般 都在RET和shellcode之间填充大量的NOP指令,使得exploit有更强的通用性。


    ├———————┤<—低端内存区域 
    │ …… │ 
    ├———————┤<—由exploit填入数据的开始 
    │ │ 
    │ buffer │<—填入无用的数据 
    │ │ 
    ├———————┤ 
    │ RET │<—指向shellcode,或NOP指令的范围 
    ├———————┤ 
    │ NOP │ 
    │ …… │<—填入的NOP指令,是RET可指向的范围 
    │ NOP │ 
    ├———————┤ 
    │ │ 
    │ shellcode │ 
    │ │ 
    ├———————┤<—由exploit填入数据的结束 
    │ …… │ 
    ├———————┤<—高端内存区域


    windows下的动态数据除了可存放在栈中,还可以存放在堆中。了解C++的朋友都知道,C++可以使用new关键字来动态分配内存。来看下面的C++代码:

    #include <stdio.h> 
    #include <iostream.h> 
    #include <windows.h>

    void func() 

    char *buffer=new char[128]; 
    char bufflocal[128]; 
    static char buffstatic[128]; 
    printf("0x%08x\n",buffer); //打印堆中变量的内存地址 
    printf("0x%08x\n",bufflocal); //打印本地变量的内存地址 
    printf("0x%08x\n",buffstatic); //打印静态变量的内存地址 
    }

    void main() 

    func(); 
    return; 
    }

    程序执行结果为:

    0x004107d0 
    0x0012ff04 
    0x004068c0

    可以发现用new关键字分配的内存即不在栈中,也不在静态数据区。VC编译器是通过windows下的“堆(heap)”来实现new关键字的内存动态分配。在讲“堆”之前,先来了解一下和“堆”有关的几个API函数:

    HeapAlloc 在堆中申请内存空间 
    HeapCreate 创建一个新的堆对象 
    HeapDestroy 销毁一个堆对象 
    HeapFree 释放申请的内存 
    HeapWalk 枚举堆对象的所有内存块 
    GetProcessHeap 取得进程的默认堆对象 
    GetProcessHeaps 取得进程所有的堆对象 
    LocalAlloc 
    GlobalAlloc

    当进程初始化时,系统会自动为进程创建一个默认堆,这个堆默认所占内存的大小为1M。堆对象由系统进行管理,它在内存中以链式结构存在。通过下面的代码可以通过堆动态申请内存空间:

    HANDLE hHeap=GetProcessHeap(); 
    char *buff=HeapAlloc(hHeap,0,8);

    其中hHeap是堆对象的句柄,buff是指向申请的内存空间的地址。那这个hHeap究竟是什么呢?它的值有什么意义吗?看看下面这段代码吧:

    #pragma comment(linker,"/entry:main") //定义程序的入口 
    #include <windows.h>

    _CRTIMP int (__cdecl *printf)(const char *, ...); //定义STL函数printf 
    /*--------------------------------------------------------------------------- 
    写到这里,我们顺便来复习一下前面所讲的知识: 
    (*注)printf函数是C语言的标准函数库中函数,VC的标准函数库由msvcrt.dll模块实现。 
    由 函数定义可见,printf的参数个数是可变的,函数内部无法预先知道调用者压入的参数个数,函数只能通过分析第一个参数字符串的格式来获得压入参数的信 息,由于这里参数的个数是动态的,所以必须由调用者来平衡堆栈,这里便使用了__cdecl调用规则。BTW,Windows系统的API函数基本上是 __stdcall调用形式,只有一个API例外,那就是wsprintf,它使用__cdecl调用规则,同printf函数一样,这是由于它的参数个 数是可变的缘故。 
    ---------------------------------------------------------------------------*/ 
    void main() 

    HANDLE hHeap=GetProcessHeap(); 
    char *buff=HeapAlloc(hHeap,0,0x10); 
    char *buff2=HeapAlloc(hHeap,0,0x10); 
    HMODULE hMsvcrt=LoadLibrary("msvcrt.dll"); 
    printf=(void *)GetProcAddress(hMsvcrt,"printf"); 
    printf("0x%08x\n",hHeap); 
    printf("0x%08x\n",buff); 
    printf("0x%08x\n\n",buff2); 
    }

    执行结果为:

    0x00130000 
    0x00133100 
    0x00133118

    hHeap 的值怎么和那个buff的值那么接近呢?其实hHeap这个句柄就是指向HEAP首部的地址。在进程的用户区存着一个叫PEB(进程环境块)的结构,这个 结构中存放着一些有关进程的重要信息,其中在PEB首地址偏移0x18处存放的ProcessHeap就是进程默认堆的地址,而偏移0x90处存放了指向 进程所有堆的地址列表的指针。windows有很多API都使用进程的默认堆来存放动态数据,如windows 2000下的所有ANSI版本的函数都是 在默认堆中申请内存来转换ANSI字符串到Unicode字符串的。对一个堆的访问是顺序进行的,同一时刻只能有一个线程访问堆中的数据,当多个线程同时 有访问要求时,只能排队等待,这样便造成程序执行效率下降。

    最后来说说内存中的数据对齐。所位数据对齐,是指数据所在的内存地址必须是该 数据长度的整数倍,DWORD数据的内存起始地址能被4除尽,WORD数据的内存起始地址能被2除尽,x86 CPU能直接访问对齐的数据,当 他试图访问 一个未对齐的数据时,会在内部进行一系列的调整,这些调整对于程序来说是透明的,但是会降低运行速度,所以编译器在编译程序时会尽量保证数据对齐。同样一 段代码,我们来看看用VC、Dev-C++和lcc三个不同编译器编译出来的程序的执行结果:

    #include <stdio.h>

    int main() 

    int a; 
    char b; 
    int c; 
    printf("0x%08x\n",&a); 
    printf("0x%08x\n",&b); 
    printf("0x%08x\n",&c); 
    return 0; 
    }

    这是用VC编译后的执行结果: 
    0x0012ff7c 
    0x0012ff7b 
    0x0012ff80 
    变量在内存中的顺序:b(1字节)-a(4字节)-c(4字节)。

    这是用Dev-C++编译后的执行结果: 
    0x0022ff7c 
    0x0022ff7b 
    0x0022ff74 
    变量在内存中的顺序:c(4字节)-中间相隔3字节-b(占1字节)-a(4字节)。

    这是用lcc编译后的执行结果: 
    0x0012ff6c 
    0x0012ff6b 
    0x0012ff64 
    变量在内存中的顺序:同上。

    三个编译器都做到了数据对齐,但是后两个编译器显然没VC“聪明”,让一个char占了4字节,浪费内存哦。


    基础知识: 
    堆 栈是一种简单的数据结构,是一种只允许在其一端进行插入或删除的线性表。允许插入或删除操作的一端称为栈顶,另一端称为栈底,对堆栈的插入和删除操作被称 为入栈和出栈。有一组CPU指令可以实现对进程的内存实现堆栈访问。其中,POP指令实现出栈操作,PUSH指令实现入栈操作。CPU的ESP寄存器存放 当前线程的栈顶指针,EBP寄存器中保存当前线程的栈底指针。CPU的EIP寄存器存放下一个CPU指令存放的内存地址,当CPU执行完当前的指令后,从 EIP寄存器中读取下一条指令的内存地址,然后继续执行。

    堆和栈的区别
    一、预备知识—程序的内存分配
    一个由c/c++编译的程序占用的内存分为以下几个部分
    1、栈区(stack)— 由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。
    2、堆区(heap) — 一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事,分配方式倒是类似于链表。
    3、全局区(静态区)(static)— 全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域, 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放 
    4、文字常量区—常量字符串就是放在这里的。 程序结束后由系统释放
    5、程序代码区—存放函数体的二进制代码。
    二、例子程序 

    //main.cpp 
    int a = 0; 全局初始化区 
    char *p1; 全局未初始化区 
    main() 

    int b; 栈 
    char s[] = "abc"; 栈 
    char *p2; 栈 
    char *p3 = "123456"; 123456\0在常量区,p3在栈上。 
    static int c =0; 全局(静态)初始化区 
    p1 = (char *)malloc(10); 
    p2 = (char *)malloc(20); 
    分配得来得10和20字节的区域就在堆区。 
    strcpy(p1, "123456"); 123456\0放在常量区,编译器可能会将它与p3所指向的"123456"优化成一个地方。 
    }


    二、堆和栈的理论知识 
    2.1申请方式 
    stack: 
    由系统自动分配。 例如,声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间 
    heap: 
    需要程序员自己申请,并指明大小,在c中malloc函数 
    如p1 = (char *)malloc(10); 
    在C++中用new运算符 
    如p2 = (char *)malloc(10); 
    但是注意p1、p2本身是在栈中的。


    2.2 
    申请后系统的响应 
    栈:只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。 
    堆:首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时, 
    会 遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将该结点的空间分配给程序,另外,对于大多数系统,会在这块内 存空间中的首地址处记录本次分配的大小,这样,代码中的delete语句才能正确的释放本内存空间。另外,由于找到的堆结点的大小不一定正好等于申请的大 小,系统会自动的将多余的那部分重新放入空闲链表中。

    2.3申请大小的限制 
    栈:在Windows下,栈是向低地址扩展的数据结 构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是2M(也有的说是1M,总之是 一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。 
    堆:堆是向高地址扩展的数据结构,是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的,自然是不连续的,而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见,堆获得的空间比较灵活,也比较大。


    2.4申请效率的比较: 
    栈由系统自动分配,速度较快。但程序员是无法控制的。 
    堆是由new分配的内存,一般速度比较慢,而且容易产生内存碎片,不过用起来最方便. 
    另外,在WINDOWS下,最好的方式是用VirtualAlloc分配内存,他不是在堆,也不是在栈是直接在进程的地址空间中保留一快内存,虽然用起来最不方便。但是速度快,也最灵活。

    2.5堆和栈中的存储内容 
    栈: 在函数调用时,第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的地址,然后是函数的各个参数,在大多数的C编译器中,参数是由右往左入栈的,然后是函数中的局部变量。注意静态变量是不入栈的。 
    当本次函数调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的地址,也就是主函数中的下一条指令,程序由该点继续运行。 
    堆:一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

    2.6存取效率的比较

    char s1[] = "aaaaaaaaaaaaaaa"; 
    char *s2 = "bbbbbbbbbbbbbbbbb"; 
    aaaaaaaaaaa是在运行时刻赋值的; 
    而bbbbbbbbbbb是在编译时就确定的; 
    但是,在以后的存取中,在栈上的数组比指针所指向的字符串(例如堆)快。 
    比如: 
    #include 
    void main() 

    char a = 1; 
    char c[] = "1234567890"; 
    char *p ="1234567890"; 
    a = c[1]; 
    a = p[1]; 
    return; 

    对应的汇编代码 
    10: a = c[1]; 
    00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh] 
    0040106A 88 4D FC mov byte ptr [ebp-4],cl 
    11: a = p[1]; 
    0040106D 8B 55 EC mov edx,dword ptr [ebp-14h] 
    00401070 8A 42 01 mov al,byte ptr [edx+1] 
    00401073 88 45 FC mov byte ptr [ebp-4],al 
    第一种在读取时直接就把字符串中的元素读到寄存器cl中,而第二种则要先把指针值读到edx中,在根据edx读取字符,显然慢了。


    2.7小结: 
    堆和栈的区别可以用如下的比喻来看出: 
    使用栈就象我们去饭馆里吃饭,只管点菜(发出申请)、付钱、和吃(使用),吃饱了就走,不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作,他的好处是快捷,但是自由度小。 
    使用堆就象是自己动手做喜欢吃的菜肴,比较麻烦,但是比较符合自己的口味,而且自由度大。


    参考:《Windows下的HEAP溢出及其利用》by: isno ,《windows核心编程》by: Jeffrey Richter

    附:

    摘要: 讨论常见的堆性能问题以及如何防范它们。

    前言
    您 是否是动态分配的 C/C++ 对象忠实且幸运的用户?您是否在模块间的往返通信中频繁地使用了“自动化”?您的程序是否因堆分配而 运行起来很慢?不仅仅 您遇到这样的问题。几乎所有项目迟早都会遇到堆问题。大家都想说,“我的代码真正好,只是堆太慢”。那只是部分正确。更深入理解堆及其用法、以及会发生什 么问题,是很有用的。

    什么是堆?
    在程序中,使用堆来动态分配和释放对象。在下列情况下,调用堆操作: 
    事先不知道程序所需对象的数量和大小。
    对象太大而不适合堆栈分配程序。
    堆使用了在运行时分配给代码和堆栈的内存之外的部分内存。下图给出了堆分配程序的不同层。

    GlobalAlloc/GlobalFree:Microsoft Win32 堆调用,这些调用直接与每个进程的默认堆进行对话。

    LocalAlloc/LocalFree:Win32 堆调用(为了与 Microsoft Windows NT 兼容),这些调用直接与每个进程的默认堆进行对话。

    COM 的 IMalloc 分配程序(或 CoTaskMemAlloc / CoTaskMemFree):函数使用每个进程的默认堆。自动化程序使用“组件对象模型 (COM)”的分配程序,而申请的程序使用每个进程 堆。

    C/C ++ 运行时 (CRT) 分配程序:提供了 malloc() 和 free() 以及 new 和 delete 操作符。如 Microsoft Visual Basic 和 Java 等语言也提供了新的操作 符并使用垃圾收集来代替堆。CRT 创建自己的私有堆,驻留在 Win32 堆的顶部。

    Windows NT 中,Win32 堆是 Windows NT 运行时分配程序周围的薄层。所有 API 转发它们的请求给 NTDLL。

    Windows NT 运行时分配程序提供 Windows NT 内的核心堆分配程序。它由 具有 128 个大小从 8 到 1,024 字节的空闲列表的前端分配程序组成。后端分 配程序使用虚拟内存来保留和提交页。

    在图表的底部是“虚拟内存分配程序”,操作系统使用它来保留和提交页。所有分配程序使用虚拟内存进行数据的存取。

    分配和释放块不就那么简单吗?为何花费这么长时间?

    堆实现的注意事项
    传 统上,操作系统和运行时库是与堆的实现共存的。在一个进程的开始,操作系统创建一个默认堆,叫做“进程堆”。如果没有其他堆可使用,则块的分配使用“进程 堆”。语言运行时也能在进程内创建单独的堆。(例如,C 运行时创建它自己的堆。)除这些专用的堆外,应用程序或许多已载入的动态链接库 (DLL) 之 一可以创建和使用单独的堆。Win32 提供一整套 API 来创建和使用私有堆。有关堆函数(英文)的详尽指导,请参见 MSDN。

    当应用程序或 DLL 创建私有堆时,这些堆存在于进程空间,并且在进程内是可访问的。从给定堆分配的数据将在同一个堆上释放。(不能从一个堆分配而在另一个堆释放。)

    在所有虚拟内存系统中,堆驻留在操作系统的“虚拟内存管理器”的顶部。语言运行时堆也驻留在虚拟内存顶部。某些情况下,这些堆是操作系统堆中的层,而语言运行时堆则通过大块的分配来执行自己的内存管理。不使用操作系统堆,而使用虚拟内存函数更利于堆的分配和块的使用。

    典 型的堆实现由前、后端分配程序组成。前端分配程序维持固定大小块的空闲列表。对于一次分配调用,堆尝试从前端列表找到一个自由块。如果失败,堆被迫从后端 (保留和提交虚拟内存)分配一个大块来满足请求。通用的实现有每块分配的开销,这将耗费执行周期,也减少了可使用的存储空间。

    Knowledge Base 文章 Q10758,“用 calloc() 和 malloc() 管理内存” (搜索 文章编号), 包含了有关这些主题的更多背景知识。另外,有关堆 实现和设计的详细讨论也可在下列著作中找到:“Dynamic Storage Allocation: A Survey and Critical Review”,作者 Paul R. Wilson、Mark S. Johnstone、 Michael Neely 和 David Boles; “International Workshop on Memory Management”, 作者 Kinross, Scotland, UK, 1995 年 9 月(http://www.cs.utexas.edu/users/oops/papers.html)(英文)。

    Windows NT 的实现(Windows NT 版本 4.0 和更新版本) 使用了 127 个大小从 8 到 1,024 字节的 8 字节对齐块空闲列表和一个“大 块”列表。“大块”列表(空闲列表[0]) 保存大于 1,024 字节的块。空闲列表容纳了用双向链表链接在一起的对 象。默认情况下,“进程堆”执行收 集操作。(收集是将相邻空闲块合并成一个大块的操作。)收集耗费了额外的周期,但减少了堆块的内部碎片。

    单一全局锁保护堆,防止多线程式的使用。(请参见“Server Performance and Scalability Killers”中的第一个注意事项, George Reilly 所著,在 “MSDN Online Web Workshop”上(站点:http://msdn.microsoft.com/workshop/server/iis/tencom.asp(英文)。)单一全局锁本质上是用来保护堆数据结构,防止跨多线程的随机存取。若堆操作太频繁,单一全局锁会对性能有不利的影响。

    什么是常见的堆性能问题?
    以下是您使用堆时会遇到的最常见问题:

    分配操作造成的速度减慢。光分配就耗费很长时间。最可能导致运行速度减慢原因是空闲列表没有块,所以运行时分配程序代码会耗费周期寻找较大的空闲块,或从后端分配程序分配新块。


    释放操作造成的速度减慢。释放操作耗费较多周期,主要是启用了收集操作。收集期间,每个释放操作“查找”它的相邻块,取出它们并构造成较大块,然后再把此较大块插入空闲列表。在查找期间,内存可能会随机碰到,从而导致高速缓存不能命中,性能降低。


    堆 竞争造成的速度减慢。当两个或多个线程同时访问数据,而且一个线程继续进行之前必须等待另一个线程完成时就发生竞争。竞争总是导致麻烦;这也是目前多处理 器系统遇到的最大问题。当大量使用内存块的应用程序或 DLL 以多线程方式运行(或运行于多处理器系统上)时将导致速度减慢。单一 锁定的使用—常用的解 决方案—意味着使用堆的所有操作是序列化的。当等待锁定时序列化会引起线程切换上下文。可以想象交叉路口闪烁的红灯处走走停停导致的速度减慢。 
    竞争通常会导致线程和进程的上下文切换。上下文切换的开销是很大的,但开销更大的是数据从处理器高速缓存中丢失,以及后来线程复活时的数据重建。

    堆 破坏造成的速度减慢。造成堆破坏的原因是应用程序对堆块的不正确使用。通常情形包括释放已释放的堆块或使用已释放的堆块,以及块的越界重写等明显问题。 (破坏不在本文讨论范围之内。有关内存重写和泄漏等其他细节,请参见 Microsoft Visual C++(R) 调试文档 。)


    频繁的分配和重分配造成的速度减慢。这是使用脚本语言时非常普遍的现象。如字符串被反复分配,随重分配增长和释放。不要这样做,如果可能,尽量分配大字符串和使用缓冲区。另一种方法就是尽量少用连接操作。
    竞争是在分配和释放操作中导致速度减慢的问题。理想情况下,希望使用没有竞争和快速分配/释放的堆。可惜,现在还没有这样的通用堆,也许将来会有。

    在所有的服务器系统中(如 IIS、MSProxy、DatabaseStacks、网络服务器、 Exchange 和其他), 堆锁定实在是个大瓶颈。处理器数越多,竞争就越会恶化。

    尽量减少堆的使用
    现在您明白使用堆时存在的问题了,难道您不想拥有能解决这些问题的超级魔棒吗?我可希望有。但没有魔法能使堆运行加快—因此不要期望在产品出货之前的最后一星期能够大为改观。如果提前规划堆策略,情况将会大大好转。调整使用堆的方法,减少对堆的操作是提高性能的良方。

    如何减少使用堆操作?通过利用数据结构内的位置可减少堆操作的次数。请考虑下列实例:

    struct ObjectA {
        // objectA 的数据 
    }

    struct ObjectB {
        // objectB 的数据 
    }

    // 同时使用 objectA 和 objectB

    //
    // 使用指针 
    //
    struct ObjectB {
        struct ObjectA * pObjA;
        // objectB 的数据 
    }

    //
    // 使用嵌入
    //
    struct ObjectB {
        struct ObjectA pObjA;
        // objectB 的数据 
    }

    //
    // 集合 – 在另一对象内使用 objectA 和 objectB
    //

    struct ObjectX {
        struct ObjectA   objA;
        struct ObjectB   objB;
    }

    避免使用指针关联两个数据结构。如果使用指针关联两个数据结构,前面实例中的对象 A 和 B 将被分别分配和释放。这会增加额外开销—我们要避免这种做法。


    把带指针的子对象嵌入父对象。当对象中有指针时,则意味着对象中有动态元素(百分之八十)和没有引用的新位置。嵌入增加了位置从而减少了进一步分配/释放的需求。这将提高应用程序的性能。


    合并小对象形成大对象(聚合)。聚合减少分配和释放的块的数量。如果有几个开发者,各自开发设计的不同部分,则最终会有许多小对象需要合并。集成的挑战就是要找到正确的聚合边界。


    内 联缓冲区能够满足百分之八十的需要(aka 80-20 规则)。个别情况下,需要内存缓冲区来保存字符串/二进制数据,但事先不知 道总字节数。估计并内 联一个大小能满足百分之八十需要的缓冲区。对剩余的百分之二十,可以分配一个新的缓冲区和指向这个缓冲区的指针。这样,就减少分配和释放调用并增加数据的 位置空间,从根本上提高代码的性能。


    在块中分配对象(块化)。块化是以组的方式一次分配多个对象的方法。如果对列表的项连续跟踪, 例如对一个 {名称,值} 对的列表,有两种选择:选择一是为每一个“名称-值”对分配一个节点;选择二是分配一个能容纳(如五个) “名称-值”对的结 构。例如,一般情况下,如果存储四对,就可减少节点的数量,如果需要额外的空间数量,则使用附加的链表指针。 
    块化是友好的处理器高速缓存,特别是对于 L1-高速缓存,因为它提供了增加的位置 —不用说对于块分配,很多数据块会在同一个虚拟页中。

    正确使用 _amblksiz。C 运行时 (CRT) 有它的自定义前端分配程序,该分配程序从后端 (Win32 堆)分配大小为 _amblksiz 的块。将 _amblksiz 设置为较高的值 能潜在地减少对后端的调用次数。这只对广泛使用 CRT 的程序适用。
    使用上述技术将获得的好处会因对象类型、大小及工作量而有所不同。但总能在性能和可升缩性方面有所收获。另一方面,代码会有点特殊,但如果经过深思熟虑,代码还是很容易管理的。

    其他提高性能的技术
    下面是一些提高速度的技术:

    使用 Windows NT5 堆 
    由于几个同事的努力和辛勤工作,1998 年初 Microsoft Windows(R) 2000 中有了几个重大改进:

    改进了堆代码内的锁定。堆代码对每堆一个锁。全局锁保护堆数据结构,防止多线程式的使用。但不幸的是,在高通信量的情况下,堆仍受困于全局锁,导致 高竞争和低性能。Windows 2000 中,锁内代码的临界区将竞争的可能性减到最小,从而提高了可伸缩性。


    使 用 “Lookaside”列表。堆数据结构对块的所有空闲项使用了大小在 8 到 1,024 字 节(以 8-字节递增)的快速高速缓存。快速高速缓存 最初保护在全局锁内。现在,使用 lookaside 列表来访问这些快速高速缓存空闲列表。这些列表不要求锁定,而是使用 64 位的互锁操作,因此提 高了性能。


    内部数据结构算法也得到改进。
    这些改进避免了对分配高速缓存的需求,但不排除其他的优化。使用 Windows NT5 堆评估您的代码;它对小于 1,024 字节 (1 KB) 的块(来自前端分配程序的块)是最佳的。GlobalAlloc () 和 LocalAlloc() 建立在同一堆上,是存取每个进程堆的通用机制。如果希望获得高的局部性能,则使用 Heap(R) API 来存取 每个进程堆,或为分配操作创建自己的堆。如果需要对大块操作,也可以直接使用 VirtualAlloc() / VirtualFree() 操作。

    上 述改进已在 Windows 2000 beta 2 和 Windows NT 4.0 SP4 中使用。改进后,堆锁的竞争率显著降低。这使所有 Win32 堆的直接用户受益。CRT 堆建立于 Win32 堆的顶部,但它使用自己的小块堆, 因而不能从 Windows NT 改进中受益。 (Visual C++ 版本 6.0 也有改进的堆分配程序。)

    使用分配高速缓存 
    分配高速缓存允许高速缓存分配的块,以便将来重用。这能够减少对进程堆(或全局堆)的分配/释放调用的次数,也允许最大限度的重用曾经分配的块。另外,分配高速缓存允许收集统计信息,以便较好地理解对象在较高层次上的使用。

    典 型地,自定义堆分配程序在进程堆的顶部实现。自定义堆分配程序与系统堆的行为很相似。主要的差别是它在进程堆的顶部为分配的对象提供高速缓存。高速缓存设 计成一套固定大小(如 32 字节、64 字节、128 字节等)。这一个很好的策略,但这种自定义堆分配程序 丢失与分配和释放的对象相关的“语义信 息”。

    与自定义堆分配程序相反,“分配高速缓存”作为每类分配高速缓存来实现。除能够提供自定义堆分配程序的所有好处之外,它们还能够保 留大量语义信息。每个分配高速缓存处理程序与一个目标二进制对象关联。它能够使用一套参数进行初始化,这些参数表示并发级别、对象大小和保持在空闲列表中 的元素的数量等。分配高速缓存处理程序对象维持自己的私有空闲实体池(不超过指定的阀值)并使用私有保护锁。合在一起,分配高速缓存和私有锁减少了与主系 统堆的通信量,因而提供了增加的并发、最大限度的重用和较高的可伸缩性。

    需要使用清理程序来定期检查所有分配高速缓存处理程序的活动情况并回收未用的资源。如果发现没有活动,将释放分配对象的池,从而提高性能。

    可以审核每个分配/释放活动。第一级信息包括对象、分配和释放调用的总数。通过查看它们的统计信息可以得出各个对象之间的语义关系。利用以上介绍的许多技术之一,这种关系可以用来减少内存分配。

    分配高速缓存也起到了调试助手的作用,帮助您跟踪没有完全清除的对象数量。通过查看动态堆栈返回踪迹和除没有清除的对象之外的签名,甚至能够找到确切的失败的调用者。

    MP 堆 
    MP 堆是对多处理器友好的分布式分配的程序包,在 Win32 SDK(Windows NT 4.0 和更新版本)中可以得到。最初由 JVert 实现, 此处堆抽象建立在 Win32 堆程序包的顶部。MP 堆创建多个 Win32 堆,并试图将分配调 用分布到不同堆,以减少在所有单一锁上的竞争。

    本 程序包是好的步骤 —一种改进的 MP-友好的自定义堆分配程序。但是,它不提供语义信息和缺乏统计功能。通常将 MP 堆作为 SDK 库来使用。如果 使用这个 SDK 创建可重用组件,您将大大受益。但是,如果在每个 DLL 中建立这个 SDK 库,将增加工作设置。

    重新思考算法和数据结构 
    要 在多处理器机器上伸缩,则算法、实现、数据结构和硬件必须动态伸缩。请看最经常分配和释放的数据结构。试问,“我能用不同的数据结构完成此工作吗?”例 如,如果在应用程序初始化时加载了只读项的列表,这个列表不必是线性链接的列表。如果是动态分配的数组就非常好。动态分配的数组将减少内存中的堆块和碎 片,从而增强性能。

    减少需要的小对象的数量减少堆分配程序的负载。例如,我们在服务器的关键处理路径上使用五个不同的对象,每个对象单独分配和释放。一起高速缓存这些对象,把堆调用从五个减少到一个,显著减少了堆的负载,特别当每秒钟处理 1,000 个以上的请求时。

    如果大量使用“Automation”结构,请考虑从主线代码中删除“Automation BSTR”,或至少避免重复的 BSTR 操作。(BSTR 连接导致过多的重分配和分配/释放操作。)

    展开全文
  • 状态机编程思想 @Link: http://www.cnblogs.com/zhanghaiba/p/3569928.html ... 以下为转载该题在状态机编程思想下详细解答过程 00)设正常状态为0,并初始为...每遍历一个字符,就依次检查下列条件,若成立

     状态机编程思想

    @Link: http://www.cnblogs.com/zhanghaiba/p/3569928.html

    http://blog.csdn.net/yuezhiren/article/details/7957823


    以下为转载该题在状态机编程思想下详细解答过程

    00)设正常状态为0,并初始为正常状态

    每遍历一个字符,就依次检查下列条件,若成立或全部检查完毕,则回到这里检查下一个字符

    01)状态0中遇到/,说明可能会遇到注释,则进入状态1          ex. int a = b; /

    02)状态1中遇到*,说明进入多行注释部分,则进入状态2         ex. int a= b; /*

    03)状态1中遇到/,说明进入单行注释部分,则进入状态4         ex. int a = b; //

    04)状态1中没有遇到*或/,说明/是路径符号或除号,则恢复状态0      ex. <secure/_stdio.h> or 5/3

    05)状态2中遇到*,说明多行注释可能要结束,则进入状态3        ex. int a = b; /*heh*

    06)状态2中不是遇到*,说明多行注释还在继续,则维持状态2       ex. int a = b; /*hehe

    07)状态3中遇到/,说明多行注释要结束,则恢复状态0          ex. int a = b; /*hehe*/

    08)状态3中不是遇到/,说明多行注释只是遇到*,还要继续,则恢复状态2  ex. int a = b; /*hehe*h

    09)状态4中遇到\,说明可能进入折行注释部分,则进入状态9       ex. int a = b; //hehe\

    10)状态9中遇到\,说明可能进入折行注释部分,则维护状态9       ex. int a = b; //hehe\\\

    11)状态9中遇到其它字符,则说明进入了折行注释部分,则恢复状态4    ex. int a = b; // hehe\a or hehe\<enter>

    12)状态4中遇到回车符\n,说明单行注释结束,则恢复状态0        ex. int a = b; //hehe<enter>

    13)状态0中遇到',说明进入字符常量中,则进入状态5           ex. char a = '

    14)状态5中遇到\,说明遇到转义字符,则进入状态6           ex. char a = '\

    15)状态6中遇到任何字符,都恢复状态5                 ex. char a = '\n 还有如'\t', '\'', '\\' 等 主要是防止'\'',误以为结束

    16)状态5中遇到',说明字符常量结束,则进入状态0            ex. char a = '\n'

    17)状态0中遇到",说明进入字符串常量中,则进入状态7         ex. char s[] = "

    18)状态7中遇到\,说明遇到转义字符,则进入状态8           ex. char s[] = "\

    19)状态8中遇到任何字符,都恢复状态7                 ex. char s[] = "\n 主要是防止"\",误以为结束

    20)状态7中遇到"字符,说明字符串常量结束,则恢复状态0        ex. char s[] = "\"hehe"

    前面说过,不同状态可以有相应的动作。比如状态0、5、6、7、8都需要输出当前字符,再考虑一些特殊情况就可以了。

    读者实现时可以借助debug宏定义,将测试语句输出到标准错误输出,需要时可以重定位到标准输出,即2>&1,然后通过重定向|到more进行查看。


    以下为转载源代码

    /*
     *Copyright (C) Zhang Haiba
     *Date 2014-02-26
     *File exercise1_23.c
     *
     *this program removes all comments in grammatical C code,
     *and as a integrity solution for exercise1-23 in <>
     */
    
    #include 
    #define debug
    //#define debug(fmt, args...) fprintf(stderr, fmt, ##args)
    
    void dfa();
    
    int main(void)
    {
        dfa();
        return 0;
    }
    
    void dfa()
    {
        int c, state;
    
        state = 0;
        while ((c = getchar()) != EOF) {
            if (state == 0 && c == '/')         // ex. [/]
                state = 1;
            else if (state == 1 && c == '*')     // ex. [/*]
                state = 2;
            else if (state == 1 && c == '/')    // ex. [//]
                state = 4;
            else if (state == 1) {                // ex. [ or 5/3]
                putchar('/');
                state = 0;
            }
    
            else if (state == 2 && c == '*')    // ex. [/*he*]
                state = 3;
            else if (state == 2)                // ex. [/*heh]
                state = 2;
    
            else if (state == 3 && c == '/')    // ex. [/*heh*/]
                state = 0;
            else if (state == 3)                // ex. [/*heh*e]
                state = 2;
    
            else if (state == 4 && c == '\\')    // ex. [//hehe\]
                state = 9;
            else if (state == 9 && c == '\\')    // ex. [//hehe\\\\\]
                state = 9;
            else if (state == 9)                // ex. [//hehe\ or //hehe\a]
                state = 4;
            else if (state == 4 && c == '\n')    // ex. [//hehe]
                state = 0;
    
            else if (state == 0 && c == '\'')     // ex. [']
                state = 5;
            else if (state == 5 && c == '\\')     // ex. ['\]
                state = 6;
            else if (state == 6)                // ex. ['\n or '\' or '\t etc.]
                state = 5;
            else if (state == 5 && c == '\'')    // ex. ['\n' or '\'' or '\t' ect.]
                state = 0;
    
            else if (state == 0 && c == '\"')    // ex. ["]
                state = 7;
            else if (state == 7 && c == '\\')     // ex. ["\]
                state = 8;
            else if (state == 8)                // ex. ["\n or "\" or "\t ect.]
                state = 7;
            else if (state == 7 && c == '\"')    // ex. ["\n" or "\"" or "\t" ect.]
                state = 0;
    
            //debug("c = %c, state = %d\n", c, state);
    
            if ((state == 0 && c != '/') || state == 5 || state == 6 || state == 7 || state == 8)
                putchar(c);
        }
    }

    详情了解见原网址链接。


    展开全文
  • 字符常量

    千次阅读 2016-12-12 20:19:51
    写出下列程序的输出结果 char* s="AAA";\ printf("%s",s); s[0]='B'; printf("%s",s);   正确答案:AAA段错误  "AAA"是字符常量。s是指针,指向这个字符常量,所以声明s的时候就有问题。 cosnt char* s="AAA...
  • 有关超显微镜的下列说法中,中正确字符不正确的是 ( )下语用超显微镜不能观看胶体粒子的形状与大小。选项型常光线透过溶胶可以从光的进行方向观察到丁达尔现象。中正确字符丁达尔效应是胶粒对光的散射作用引起的。在...
  • 计算机二级C语言 考点06 字符型常量变量1、已...2、已知大写字母A的ASCII码是65,小写字母a的ASCII码是97,则用八进制表示的字符常量'\101'是______。A) 字符AB) 字符aC) 字符eD) 非法的常量3、以下程序运行后的输出...
  • 字符常量到底存放在哪个存储区

    万次阅读 多人点赞 2013-02-23 16:57:57
    字符常量,放在哪个存储区呢?是“自动存储区”还是“静态存储区”中? 比如: char *pstr="hello world!"; 这里,"hello world!"是一个字符常量, pstr是在栈中的变量。 我想问,字符常量,在...
  • 思考下列表达式代表什么意思??? 1:“zyh_helen”+ 1 2: *“zyh_helen” ...当一个字符常量出现在表达式中时,他的值是一个指针常量。编译器把这些指定字符的一份拷贝存储在内存中的某个位置,并存
  • 字符常量放在只读存储区

    千次阅读 2016-07-15 20:29:39
    给出以下定义,下列哪些操作是合法的? 1 2 const char *p1 = “hello”; char *const p2 = “world”; 正确答案: A 你的答案: C (错误) p1...
  • 我在招聘的时候也偶尔会问应聘者相关的问题,倒不是说一定要回答的特别正确和深入,通常问这些问题的目的有两个,第一是考察对 JAVA 基础知识的了解程度,第二是考察应聘者对技术的态度。  ...
  • 但是,你不能把字符常量赋值给一个字符数组,因为字符常量的直接值是一个指针,而不是这些字符本身。 举例如下: char s[20]; s="helo";//这样是错误的 char s[20]; char ss[]="hello"; s=ss;//这也是...
  • 题目:以下关于变量和常量的叙述中,正确的是() A.变量的取值在程序运行过程中可以改变,常量则不行 B.变量具有类型属性,常量则没有 C.变量具有对应的存储单元,常量则没有 D.可以对变量赋值,不能对常量赋值...
  • 整理C语言知识点 基类型,指针运算,指针变量,数组指针,字符串指针,函数指针,文字常量
  • 2、常量 三、例题 四、思考题 一、前言 1、上节课回顾 上一次给大家讲了C++数据类型还有C++注释,在以后的代码中,随着代码的增多,注释是必不可少的,它会提示我们代码功能,变量含义等等。所以我们要熟练掌握...
  • 下列选项中不是常量的是().: 选项 中 常量下列选项中不是常量的是( ).: 选项 中 常量将100声明为符号常量NUM的正确的预处理命令是______: 声明 符号 常量 NUM 预处理 命令下列常量中不是字符常量的是_____。: 常量...
  • C语言--符号常量

    千次阅读 2016-09-25 15:33:07
    在C语言中,可以用一个标识符来表示一个常量,称之为符号常量。其特点是编译后写在代码区,不可寻址,不可更改,属于指令的一部分。 符号常量有以下几种方式定义: 一、#define 符号常量在使用之前必须先定义,其...
  • AHK常量

    千次阅读 2015-07-14 13:57:23
    特殊字符 A_Space 此变量包含单个空格字符. 请参阅 AutoTrim 了解详情. A_Tab 此变量包含单个 tab 字符. 请参阅 AutoTrim 了解详情. 脚本属性 1, 2, 3 等 每当启动带命令行参数的脚本时, 会自动创建这些...
  • ado常量大全

    千次阅读 2013-12-13 13:38:16
    下列常量是由ADO预先定义的。对于脚本语言,这些常量包含在adovbs.inc或adojava.inc中,这些文件存放在\programFiles\CommonFiles\system\ado目录中。对于ASP,既可以包含这些文件,也可以使用一个METADATA标记引用...
  • Java面试题之变量与常量(二)

    千次阅读 2020-06-30 23:29:11
    零、单选 以下字符型字面值中,不合法的是? A....B....’ C....D....答案与解析:本题考查字符...以下哪个选项是字符型字面值的正确表示方式? A. F B. ‘F’ C. ‘EF’ D. “AB” 答案与解析:本题考查字符型字面值的表示方式
  • 请说明下列表达式是否正确,如果正确请写出最后的a值 1. a += a++; 2. a++ = a; 3. a-- = a++; 我给出的结果是:都不正确,属于“未定义行为”,不同编译器不同环境可能得到不同结果,属于不良写法。 [color=...
  • C语言中对字符字符串的处理很是频繁,但是C语言本身是没有字符串类型的,字符串通常放在常量字符串中或者字符数组中。字符常量适用于那些对它不做修改的字符串函数. 一、求字符串长度 strlen size_t strlen...
  • C++常量与变量

    2018-02-28 17:35:29
    常量1、整型常量整型常量即以文字形式出现的整数,包括正整数、负整数和零。整型常量的表示形式有十进制、八进制和十六进制。十进制整型常量的一般形式:[+|-]若干个0~9的数字即符号加若干个0~9的数字,但数字部分不...
  • Java枚举(Enum)类型使用的正确姿势

    千次阅读 2020-07-09 07:23:37
    通过枚举类直接调用使用下面的常量,返回的类型也是枚举类型。代码如下: SeasonEnum season = SeasonEnum.SPRING; Assert.assertTrue(season.equals(SeasonEnum.SPRING)); Assert.assertTrue(season.name()....
  • C风格字符

    千次阅读 2007-08-04 15:36:00
    小心:尽管C++支持C风格字符串,但不应该在C++程序中使用这个类型.C风格字符串常常带来许多错误,是导致大量安全问题的根源在前面我们使用过字符串字面值,并了解字符串字面值的类型是字符常量的数组, 现在可以更明确地...
  • 字符串题目

    千次阅读 2014-11-17 21:34:04
    #include #include #include #include using namespace std; void stringFilter(const char *p_str, long len, char *p_outstr) {  int count[26]={0}; //计数器  char tmp;  int j=0;  for(int i=0;i
  • P1和P2都是字符指针,所以字符串"hello"和"world"都是字符常量,不能修改,所以操作2 4都不合法。 P2是指针常量,也就是说P2的地址是不能修改的,操作3:P2++不合法。 P1是常量指针,指针指向的内容是常量,不能...
  • 字符集编码详解

    千次阅读 2013-09-12 00:29:17
    1. 编码问题的由来,相关概念的理解1.1 字符与编码的发展从计算机对多国语言的支持角度看,大致可以分为三个阶段: 系统内码 说明 系统 阶段一 ASCII 计算机刚
  • C语言期末复习题.docx

    2020-03-06 20:42:18
    基本数据类型 一选择题 1下列数据中不正确的数值或字符常量是D A0.825e2 B5L C0xabcd Do13 2以下字符中不正确的C语言转义字符是B A'\\' B'\018' C'\xaa' D'\t' 3已知大写字母A的A SCII码值是65小写字母a的A SCII码是...
  • C和C++中全局变量,局部变量,静态变量和常量

    千次阅读 多人点赞 2016-08-14 22:54:15
    C/C++中常量,静态变量,全局变量和局部变量的区别和作用。把局部变量改变为静态局部变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态全局变量是改变了它的作用域, 限制了它的使用范围。因此...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,437
精华内容 12,174
关键字:

下列正确的字符常量