关于静态变量，每new一个对象，静态变量不重置么？【java吧】_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：716,825贴子：
关于静态变量，每new一个对象，静态变量不重置么？收藏
代码如下：其中小孩类中定义了一个类变量total，初始化为0，我就问，每新建一个小孩对象total不会重置为0么？求大神帮忙。public class demo3{ public static void main(String args[]) {
Child ch1=new Child(2,"xiaoming");
ch1.joinGame();
Child ch2=new Child(4,"xiaoqiang");
ch2.joinGame();
Child ch3=new Child(6,"xiaohong");
ch3.joinGame();
System.out.println("小孩总数是："+ch3.total); }} class Child{
public Child(int age,String name) {
this.name= }
public void joinGame() {
System.out.println("有一个小孩加入了"); }}
软件培训公司,博为峰软件培训免费试听,0元入学,签署就业保障协议,不就业不收费!博为峰,真正的为年轻人服务的企业,14年间培训15万余名软件工程师,成绩斐然!
静态变量根对象没什么关系
本人离你三尺开外，便感觉有股英雄气扑面而来，细细一看，果然是个百年难遇的可造之材，筋骨奇佳！我给你推荐一java群，里边有各种java人，相信你在里边经过刻苦修炼，一定可以问鼎java巅峰，小伙子加油啊！java的未来就靠你了！记得+
静态变量只在类加载的时候加载，有且只加载一次，所以创建ch1时total被创建，但后面的ch2ch3创建时total不会被重新赋值
静态变量是类共有的，所以会变的
这个问题其实很简单，没带static的变量属于对象，带了static的变量属于类本身，每一个类对只应一个class，在这个class被加载时，系统会在堆内存中为它分配一个空间，但每一个类可以创建出它的多个实例（也就是对象），当你在创建对像时系统会为你的每一个对像在堆内存中分配空间，这些对像都保存了对类中static的一个引用，也就是说不管你创建多少个对像，它们都指向同一个static变量，因此上面你创建了三个对像并调用了3次ch3.joinGame();你的tatol就是自加3次，所以它最终的结果是3
登录百度帐号1.静态成员、实例成员
3.类的静态成员和非静态成员区别
--------------------------------------分割线---------------------------------------------
1.静态成员、实例成员
1.1定义及说明
　　数据成员：
静态成员：静态成员变量是和类相关联的,可以作为类中"共"有的变量(是一个共性的表现),他不依赖特定对象的存在,访问的时候通过类名加点操作符加变量名来访问.
实例成员：实例成员变量是和对象相关联的,访问实例成员变量依赖于实例的存在.
　　函数成员：静态方法：静态方法是不属于特定对象的方法,静态方法可以访问静态成员变量和静态方法；静态方法不可以直接访问实例变量和实例方法，可以间接调用，首先要创建一个类的实例，然后通过这一特定对象来调用静态方法；
实例方法：一个实例方法的执行与特定对象关联，他的执行需要一个对象存在。实例方法可以直接访问静态变量和实例变量，当多个实例对象存在时，内存中并不是存在美个特定的实例方法的拷贝，而是，相同类的所有对象都共享每个实例方法的一个拷贝（实例方法只占用&一套&空间）。
静态方法和实例方法的访问权限表
静态成员变量
实例成员变量
不可直接访问
不可直接访问
总之：实例方法的存在必须要有对象实例的存在，如果对象实例不存在，则实例方法也就没有调用它的主人。静态方法的存在前提是类的存在，所以无需声明和New对象。
1.2代码演示 &
class Program
static void Main(string[] args)
Class1.CallObjectFunc();//静态调用
Console.WriteLine(Environment.NewLine);
Class1 tmpClass = new Class1();//实例调用
tmpClass.ObjectFunc();
Console.ReadKey();
class Class1
static int Class_m = 9;//静态成员
private int object_m = 8;//实例成员
public static void CallObjectFunc()
Console.WriteLine("------------静态方法调用开始:");
Class1 class1 = new Class1();
class1.ObjectFunc();
Console.WriteLine("object_m:" + class1.object_m.ToString());
Console.WriteLine("------------静态方法调用结束:");
public void ObjectFunc()
Console.WriteLine("实例方法调用开始:");
Console.WriteLine("Class_m：" + Class_m.ToString());
Console.WriteLine("实例方法调用结束:");
类可以声明为&static&的，以指示它仅包含静态成员。不能使用&new&关键字创建静态类的实例。例如，创建一组不操作实例数据并且不与代码中的特定对象关联的方法是很常见的要求。您应该使用静态类来包含那些方法。
静态类的主要功能如下：
它们仅包含静态成员。----函数成员和变量都必须有static修饰
它们不能被实例化。
它们是密封的。-----------编译器编译时自动生成sealed标记
它们不能包含实例构造函数。
因此创建静态类与创建仅包含静态成员和私有构造函数的类大致一样。私有构造函数阻止类被实例化。
使用静态类的优点在于，编译器能够执行检查以确保不致偶然地添加实例成员。编译器将保证不会创建此类的实利。
静态类是密封的，因此不可被继承。静态类不能包含构造函数，但仍可声明静态构造函数以分配初始值或设置某个静态状态。
static class CompanyInfo
public static string GetCompanyName() { return "CompanyName"; }
public static string GetCompanyAddress() { return "CompanyAddress"; }
&3.类的静态成员和非静态成员区别
& & 3.1区别
（1）语法区别：静态成员有关键字static，非静态成员无static修饰；
（2）存储区别: &静态成员变量存储位于程序的全局变量存储区，其作用域限制为类内部，并且在整个程序运行期间只在内存中拥有一个存储位置，不会拷贝不会复制，只是一个；
& & & & & & & & & & & 非静态成员变量存储位于对象的变量存储区，多个对象拥有多个变量的存储，只隶属于自己的的对象
（3）归属区别：静态成员隶属于类，是类的财产，无论对一个类创建多少个实例，它的静态成员都只有一个副本，在各个地方的改变都会改变其值；
& & & & & & & & & & &非静态成员隶属于它的对象，各自对象同一个非静态成员值的改变都不互相影响，有多少实例就有多少副本；
（4）生存周期区别: 知道了存储位置的区别也就不难理解生存周期的差异了，静态成员只要分配了空间则在整个程序运行期间，它都是存在的，只有程序关闭之后，它的内存才会被GC回收器收回，不过作用域仍然只限制于类的内部，在类外部调用时需要使用类 & & & & & & & & & & & & & & & & & & &名加点的方式访问；
& & & & & & & & & & & & & &类的非静态成员的生存周期跟随于隶属于对象的生存周期，对象消亡则非静态成员就会被回收；
（5）初始化顺序的区别:初始化都是最先初始化类的静态成员，然后才是非静态数据成员。
& & & 3.2代码：
下面代码的输出是多少呢？先自己思考
using System.Collections.G
using System.L
using System.T
class class1
private static int i = getNum();
private static int num = 1;
int j = getNum();
private static int getNum()
static void Main(string[] args)
Console.WriteLine("i={0}", i);
class1 class1Object = new class1();//默认构造函数
Console.WriteLine("j={0}", class1Object.j);
Console.WriteLine("i={0}", i);
Console.ReadKey();
输出结果为：
　　　　　　
额，怎么回事这样呢？是不是会和你想的不一样，如果你真有这种想法，说明还需要看我下面的分析噢
类结构:这个类有三个变量，两个私有静态成员变量i和num，一个非静态成员变量j;一个私有静态函数getNum()，一个函数入口Main()
程序执行过程:首先之前说了初始化会首先初始化类的静态变量。
i分配空间并初始化值为0--&num分配空间并初始化为0--&i赋值(调用getNum函数，此时num为0，返回值为0，所以i=0)--&num赋值为1--&Main函数
至于Main函数内执行时，为什么i输出不是1呢?这是因为静态成员只初始化一次，所以此时调用i并不会再调用getNum()函数为其赋值，此时的调用i是获取i分配空间上的值。
(题外:初学程序的人闹不清楚变量声明、分配空间和赋值的概念，C#是强类型语言，分配空间就是为变量分配符合变量前类型修饰符的空间大小，int就分配四字节，char就分配1字节，关于声明和赋值不在本文探讨范围内，读者可自行百度）
由于本人才学识前，描述难免纰漏，如有错误，欢迎指出。部分引用和参考无法详细查证，若遇本尊驾临，可告知，将附上引用地址和出处，么么！
& & & & & & & & &&
阅读(...) 评论()**提示 - 中国广告知道网
为了能够更快的帮助网友解决“**提示”相关的提问，中国广告知道网通过互联网大数据对“**提示”相关的解决方案进行了整理,用户详细提问包括:**提示与之相关的答案，具体解决方案如下：
提问者悬赏：<font color="#FF分 发布者：匿名网友
提问时间：
详细问题描述及疑问：期待您的答案，谢谢你帮我,祝你快乐,愿你事事如意！
网友们正在为您出谋划策，请耐心等待！
|||||||||||||
猜您感兴趣
热门搜索：
本页网址：你的位置：& & &
蜂蜜和什么不能同吃 16种相克食物
1、豆腐蜂蜜伴着吃,味道虽好耳要聋. 2、洋葱蜂蜜也不合,同食就会伤眼睛.3、蜂糖与生葱：食则死亡。解救：米炒枯研末，再用甘草二两煎水冲枯米吃；4、鲫鱼与蜂糖；食则中毒。解救：吃黑豆甘汤草5、韭菜：不可与蜂蜜同食，同食会阻碍血液循环则令人心痛；6、苦菜： 不可与蜂蜜同食7、蜜： 不宜与葱、蒜、韭菜、莴苣、豆腐同食，不然易引起腹泄8、蜜+毛蟹： 同食会引起中毒，可以用地浆水治疗。9、热水+蜜糖： 同食会使蜂蜜中的营养成份受到破坏。10、蜂蜜+大米： 同食会胃痛11、蜜：忌地黄、何首乌蜂蜜和什么不能同吃 16种相克食物：动态变量和静态变量的区别，堆和栈的区别
我的图书馆
动态变量和静态变量的区别，堆和栈的区别
动态变量和静态变量的区别：1、存储位置动态变量：存储在内存出栈数据区静态变量：存储在全局数据区（静态数据区）2、生命期动态变量：根据你定义的位置确定，比如你在一个函数中定义的，那么超出该函数范围变量将失效静态变量：程序结束时才释放3、作用域动态变量：同样的要根据你定义的位置才能确定，和第二点的一样静态变量：当前文件中有效堆和栈的区分：堆（Heap）栈（Stack）1、内存分配方面：堆：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式是类似于链表。可能用到的关键字如下：new、malloc、delete、free等等。栈：由编译器(Compiler)自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。2、申请方式方面：堆：需要程序员自己申请，并指明大小。在c中malloc函数如p1 = (char *)malloc(10)；在C++中用new运算符，但是注意p1、p2本身是在栈中的。因为他们还是可以认为是局部变量。栈：由系统自动分配。 例如，声明在函数中一个局部变量 int b；系统自动在栈中为b开辟空间。3、系统响应方面：堆：操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样代码中的delete语句才能正确的释放本内存空间。另外由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。4、大小限制方面：堆：是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。栈：在Windows下, 栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是固定的（是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。5、效率方面：堆：是由new分配的内存，一般速度比较慢，而且容易产生内存碎片，不过用起来最方便，另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。栈：由系统自动分配，速度较快。但程序员是无法控制的。6、存放内容方面：堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。栈：在函数调用时第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈，然后是函数中的局部变量。&注意: 静态变量是不入栈的。当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。7、存取效率方面：堆：char *s1 = "Hellow Word"；是在编译时就确定的；栈：char s1[] = "Hellow Word"； 是在运行时赋值的；用数组比用指针速度要快一些，因为指针在底层汇编中需要用edx寄存器中转一下，而数组在栈上直接读取。2.&堆和栈的区别 (stack and heap)一般认为在c中分为这几个存储区&1栈 - 有编译器自动分配释放&2堆 - 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收&3全局区（静态区），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 程序结束释放。&4另外还有一个专门放常量的地方。 - 程序结束释放在函数体中定义的变量通常是在栈上，用malloc, calloc, realloc等分配内存的函数分配得到的就是在堆上。在所有函数体外定义的是全局量，加了static修饰符后不管在哪里都存放在全局区（静态区）,在所有函数体外定义的static变量表示在该文件中有效，不能extern到别的文件用，在函数体内定义的static表示只在该函数体内有效。另外，函数中的 "adgfdf "这样的字符串存放在常量区。&比如：&int a = 0; 全局初始化区&char *p1; 全局未初始化区&main()&{& 栈&char s[] = "abc ";栈&char *p2; 栈&char *p3 = "123456 "; 在常量区，p3在栈上。&static int c =0； 全局（静态）初始化区&p1 = (char *)malloc(10);&p2 = (char *)malloc(20);&分配得来得10和20字节的区域就在堆区。&strcpy(p1, "123456 "); 放在常量区，编译器可能会将它与p3所指向的 "12345&6 "优化成一块。&}还有就是函数调用时会在栈上有一系列的保留现场及传递参数的操作。栈的空间大小有限定，vc的缺省是2M。栈不够用的情况一般是程序中分配了大量数组和递归函数层次太深。有一点必须知道，当一个函数调用完返回后它会释放该函数中所有的栈空间。栈是由编译器自动管理的，不用你操心。堆是动态分配内存的，并且你可以分配使用很大的内存。但是用不好会产生内存泄漏。并且频繁地malloc和free会产生内存碎片（有点类似磁盘碎片），因为c分配动态内存时是寻找匹配的内存的。而用栈则不会产生碎片。在栈上存取数据比通过指针在堆上存取数据快些。一般大家说的堆栈和栈是一样的，就是栈(stack)，而说堆时才是堆heap.栈是先入后出的，一般是由高地址向低地址生长。&堆(heap)和栈(stack)是C/C++编程不可避免会碰到的两个基本概念。首先，这两个概念都可以在讲数据结构的书中找到，他们都是基本的数据结构，虽然栈更为简单一些。在具体的C/C++编程框架中，这两个概念并不是并行的。对底层机器代码的研究可以揭示，栈是机器系统提供的数据结构，而堆则是C/C++函数库提供的。具体地说，现代计算机(串行执行机制)，都直接在代码底层支持栈的数据结构。这体现在，有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入栈出栈的操作。这种机制的特点是效率高，支持的数据有限，一般是整数，指针，浮点数等系统直接支持的数据类型，并不直接支持其他的数据结构。因为栈的这种特点，对栈的使用在程序中是非常频繁的。对子程序的调用就是直接利用栈完成的。机器的call指令里隐含了把返回地址推入栈，然后跳转至子程序地址的操作，而子程序中的ret指令则隐含从堆栈中弹出返回地址并跳转之的操作。C/C++中的自动变量是直接利用栈的例子，这也就是为什么当函数返回时，该函数的自动变量自动失效的原因(因为 颜换指戳说饔们暗 状态)。&和栈不同，堆的数据结构并不是由系统(无论是机器系统还是操作系统)支持的，而是由函数库提供的。基本的malloc/realloc/free函数维护了一套内部的堆数据结构。当程序使用这些函数去获得新的内存空间时，这套函数首先试图从内部堆中寻找可用的内存空间，如果没有可以使用的内存空间，则试图利用系统调用来动态增加程序数据段的内存大小，新分配得到的空间首先被组织进内部堆中去，然后再以适当的形式返回给调用者。当程序释放分配的内存空间时，这片内存空间被返回内部堆结构中，可能会被适当的处理(比如和其他空闲空间合并成更大的空闲空间)，以更适合下一次内存分配申请。这套复杂的分配机制实际上相当于一个内存分配的缓冲池(Cache)，使用这套机制有如下若干原因：&1. 系统调用可能不支持任意大小的内存分配。有些系统的系统调用只支持固定大小及其倍数的内存请求(按页分配)；这样的话对于大量的小内存分类来说会造成浪费。&2. 系统调用申请内存可能是代价昂贵的。系统调用可能涉及用户态和核心态的转换。&3. 没有管理的内存分配在大量复杂内存的分配释放操作下很容易造成内存碎片。&堆和栈的对比&从以上知识可知，栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；而栈是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率有一定降低。栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。不同堆分的内存无法互相操作。栈空间分静态分配和动态分配两种。静态分配是编译器完成的，比如自动变量(auto)的分配。动态分配由alloca函数完成。栈的动态分配无需释放(是自动)，也就没有释放函数。为可移植的程序起见，栈的动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/释放内存匹配是良好程序的基本要素。&可以放一块思考&堆和栈的生长方向恰好相反，&|--------------| 低地址&| 堆 |&|--------------|&| | |&| I |&| |&| ^ |&| 栈 | 高地址&-----------------&所以计算机中的堆和栈经常时放一块讲的&nod 一般不是必要就不要动态创建，最讨厌把new出来的东西当局部变量用，用万了马上delete 的做法.&理由&1.栈分配比堆快，只需要一条指令就呢给配所有的局部变量&2.栈不会出现内存碎片&3。栈对象好管理&当然，某些情况下也要那么写,比如&1.对象很大&2.对象需要在某个特定的时刻构造或析够&3.类只允许对象动态创建,比如VCL的大多数类&当然，必须用堆对象时也不能躲避堆内存和栈内存各有什么作用？堆：顺序随意栈：先进后出堆和栈的区别一、预备知识—程序的内存分配一个由c/C++编译的程序占用的内存分为以下几个部分1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放4、文字常量区 —常量字符串就是放在这里的。 程序结束后由系统释放&5、程序代码区—存放函数体的二进制代码。二、例子程序这是一个前辈写的，非常详细//main.cpp&int a = 0; 全局初始化区char *p1; 全局未初始化区main(){&&&&&&&&& 栈&&&&& char s[] = "abc"; 栈&&&&&& char *p2; 栈&&&&&& char *p3 = "123456"; 在常量区，p3在栈上。&&&&&& static int c =0； 全局（静态）初始化区&&&&&& p1 = (char *)malloc(10);&&&&&& p2 = (char *)malloc(20);&&&&&& 分配得来得10和20字节的区域就在堆区。&&&&&& strcpy(p1, "123456"); 放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。&}&二、堆和栈的理论知识2.1申请方式stack:由系统自动分配。 例如，声明在函数中一个局部变量 系统自动在栈中为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是在编译时就确定的；但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。&比如：＃i ncludevoid main(){&&&&&&&&& char a = 1;&&&&&&&&&& char c[] = "";&&&&&&&&&& char *p ="";&&&&&&&&& a = c[1];&&&&&&&&&& a = p[1];&&&&&&&&&&&&&&&}&对应的汇编代码&10: a = c[1];&A 4D F1 mov cl,byte ptr [ebp-0Fh] 4D FC mov byte ptr [ebp-4],cl&11: a = p[1];&B 55 EC mov edx,dword ptr [ebp-14h]&A 42 01 mov al,byte ptr [edx+1]& 45 FC mov byte ptr [ebp-4],al&第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。&2.7小结：堆和栈的区别可以用如下的比喻来看出：使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。 使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。&堆和栈的区别主要分：&操作系统方面的堆和栈，如上面说的那些，不多说了。还有就是数据结构方面的堆和栈，这些都是不同的概念。这里的堆实际上指的就是（满足堆性质的）优先队列的一种数据结构，第1个元素有最高的优先权；栈实际上就是满足先进后出的性质的数学或数据结构。虽然堆栈，堆栈的说法是连起来叫，但是他们还是有很大区别的，连着叫只是由于历史的原因。
喜欢该文的人也喜欢