Java把内存分成两种，一种叫做栈内存，一种叫做堆内存
在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配。当在一段代码块中定义一个变量时，java就在栈中为这个变量分配内存空间，当超过变量的作用域后，java会自动释放掉为该变量分配的内存空间，该内存空间可以立刻被另作他用。
堆内存用于存放由new创建的对象和数组。在堆中分配的内存，由java虚拟机自动垃圾回收器来管理。在堆中产生了一个数组或者对象后，还可以在栈中定义一个特殊的变量，这个变量的取值等于数组或者对象在堆内存中的首地址，在栈中的这个特殊的变量就变成了数组或者对象的引用变量，以后就可以在程序中使用栈内存中的引用变量来访问堆中的数组或者对象，引用变量相当于为数组或者对象起的一个别名，或者代号。
引用变量是普通变量，定义时在栈中分配内存，引用变量在程序运行到作用域外释放。而数组＆对象本身在堆中分配，即使程序运行到使用new产生数组和对象的语句所在地代码块之外，数组和对象本身占用的堆内存也不会被释放，数组和对象在没有引用变量指向它的时候，才变成垃圾，不能再被使用，但是仍然占着内存，在随后的一个不确定的时间被垃圾回收器释放掉。这个也是java比较占内存的主要原因，实际上，栈中的变量指向堆内存中的变量，这就是 Java 中的指针!
java中内存分配策略及堆和栈的比较 　　1 内存分配策略 　　按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的. 　　静态存储分配是指在编译时就能确定每个数据目标在运行时刻的存储空间需求,因而在编译时就可以给他们分配固定的内存空间.这种分配策略要求程序代码中不允许有可变数据结构(比如可变数组)的存在,也不允许有嵌套或者递归的结构出现,因为它们都会导致编译程序无法计算准确的存储空间需求. 　　栈式存储分配也可称为动态存储分配,是由一个类似于堆栈的运行栈来实现的.和静态存储分配相反,在栈式存储方案中,程序对数据区的需求在编译时是完全未知的,只有到运行的时候才能够知道,但是规定在运行中进入一个程序模块时,必须知道该程序模块所需的数据区大小才能够为其分配内存.和我们在数据结构所熟知的栈一样,栈式存储分配按照先进后出的原则进行分配。 　　静态存储分配要求在编译时能知道所有变量的存储要求,栈式存储分配要求在过程的入口处必须知道所有的存储要求,而堆式存储分配则专门负责在编译时或运行时模块入口处都无法确定存储要求的数据结构的内存分配,比如可变长度串和对象实例.堆由大片的可利用块或空闲块组成,堆中的内存可以按照任意顺序分配和释放. 　　2 堆和栈的比较 　　上面的定义从编译原理的教材中总结而来,除静态存储分配之外,都显得很呆板和难以理解,下面撇开静态存储分配,集中比较堆和栈: 　　从堆和栈的功能和作用来通俗的比较,堆主要用来存放对象的，栈主要是用来执行程序的.而这种不同又主要是由于堆和栈的特点决定的: 　　在编程中，例如C/C++中，所有的方法调用都是通过栈来进行的,所有的局部变量,形式参数都是从栈中分配内存空间的。实际上也不是什么分配,只是从栈顶向上用就行,就好像工厂中的传送带(conveyor belt)一样,Stack Pointer会自动指引你到放东西的位置,你所要做的只是把东西放下来就行.退出函数的时候，修改栈指针就可以把栈中的内容销毁.这样的模式速度最快, 当然要用来运行程序了.需要注意的是,在分配的时候,比如为一个即将要调用的程序模块分配数据区时,应事先知道这个数据区的大小,也就说是虽然分配是在程序运行时进行的,但是分配的大小多少是确定的,不变的,而这个"大小多少"是在编译时确定的,不是在运行时. 　　堆是应用程序在运行的时候请求操作系统分配给自己内存，由于从操作系统管理的内存分配,所以在分配和销毁时都要占用时间，因此用堆的效率非常低.但是堆的优点在于,编译器不必知道要从堆里分配多少存储空间，也不必知道存储的数据要在堆里停留多长的时间,因此,用堆保存数据时会得到更大的灵活性。事实上,面向对象的多态性,堆内存分配是必不可少的,因为多态变量所需的存储空间只有在运行时创建了对象之后才能确定.在C++中，要求创建一个对象时，只需用 new命令编制相关的代码即可。执行这些代码时，会在堆里自动进行数据的保存.当然，为达到这种灵活性，必然会付出一定的代价:在堆里分配存储空间时会花掉更长的时间!这也正是导致我们刚才所说的效率低的原因,看来列宁同志说的好,人的优点往往也是人的缺点,人的缺点往往也是人的优点(晕~). 　　3 JVM中的堆和栈 　　JVM是基于堆栈的虚拟机.JVM为每个新创建的线程都分配一个堆栈.也就是说,对于一个Java程序来说，它的运行就是通过对堆栈的操作来完成的。堆栈以帧为单位保存线程的状态。JVM对堆栈只进行两种操作:以帧为单位的压栈和出栈操作。 　　我们知道,某个线程正在执行的方法称为此线程的当前方法.我们可能不知道,当前方法使用的帧称为当前帧。当线程激活一个Java方法,JVM就会在线程的 Java堆栈里新压入一个帧。这个帧自然成为了当前帧.在此方法执行期间,这个帧将用来保存参数,局部变量,中间计算过程和其他数据.这个帧在这里和编译原理中的活动纪录的概念是差不多的. 　　从Java的这种分配机制来看,堆栈又可以这样理解:堆栈(Stack)是操作系统在建立某个进程时或者线程(在支持多线程的操作系统中是线程)为这个线程建立的存储区域，该区域具有先进后出的特性。 　　每一个Java应用都唯一对应一个JVM实例，每一个实例唯一对应一个堆。应用程序在运行中所创建的所有类实例或数组都放在这个堆中,并由应用所有的线程共享.跟C/C++不同，Java中分配堆内存是自动初始化的。Java中所有对象的存储空间都是在堆中分配的，但是这个对象的引用却是在堆栈中分配,也就是说在建立一个对象时从两个地方都分配内存，在堆中分配的内存实际建立这个对象，而在堆栈中分配的内存只是一个指向这个堆对象的指针(引用)而已。 　　Java 中的堆和栈 　　Java把内存划分成两种：一种是栈内存，一种是堆内存。 　　在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。 　　当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。 　　堆内存用来存放由new创建的对象和数组。 　　在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。 　　在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。 　　引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。 　　具体的说： 　　栈与堆都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。 　　Java的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。 　　栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量(,int, short, long, byte, float, double, boolean, char)和对象句柄。 　　栈有一个很重要的特殊性，就是存在栈中的数据可以共享。假设我们同时定义： 　　int a = 3; 　　int b = 3; 　　编译器先处理int a = 3;首先它会在栈中创建一个变量为a的引用，然后查找栈中是否有3这个值，如果没找到，就将3存放进来，然后将a指向3。接着处理int b = 3;在创建完b的引用变量后，因为在栈中已经有3这个值，便将b直接指向3。这样，就出现了a与b同时均指向3的情况。这时，如果再令a=4;那么编译器会重新搜索栈中是否有4值，如果没有，则将4存放进来，并令a指向4;如果已经有了，则直接将a指向这个地址。因此a值的改变不会影响到b的值。要注意这种数据的共享与两个对象的引用同时指向一个对象的这种共享是不同的，因为这种情况a的修改并不会影响到b, 它是由编译器完成的，它有利于节省空间。而一个对象引用变量修改了这个对象的内部状态，会影响到另一个对象引用变量
阅读(...) 评论()4389人阅读
//顺序栈的应用：表达式求值
//允许用户输入空格（系统自动删除），只能进行整数的四则运算，支持小括号
//对不能整除的将按两个整数除法规则进行取整
//作者：nuaazdh
//时间：日 10:49:39
#include &stdio.h&
#include &stdlib.h&
#define OK
#define ERROR
#define TRUE
#define FALSE
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define BUFFERSIZE 256
typedef int S //函数返回状态
typedef int opndE
//操作数元素类型
typedef struct{//操作数栈结构定义
opndElem *
opndElem *
typedef char optrE//操作符元素类型
typedef struct{//操作符栈结构定义
optrElem *
optrElem *
//==========操作数栈=============//
Status InitStack_OPND(OpndStack *S);
//构造一个空栈S
Status GetTop_OPND(OpndStack S,opndElem *e);
//若栈不为空，则用e返回S的栈顶元素，并返回OK；否则返回FALSE
Status Push_OPND(OpndStack *S,opndElem e);
//插入元素e为新的栈顶元素
Status Pop_OPND(OpndStack *S,opndElem *e);
//若栈S不为空，则删除S的栈顶元素，用e返回其值，并返回OK,否则返回ERROR
//==========操作符栈=============//
Status InitStack_OPTR(OptrStack *S);
//构造一个空栈S
optrElem GetTop_OPTR(OptrStack S);
//若栈不为空，则用e返回S的栈顶元素，并返回OK；否则返回FALSE
Status Push_OPTR(OptrStack *S,optrElem e);
//插入元素e为新的栈顶元素
Status Pop_OPTR(OptrStack *S,optrElem *e);
//若栈S不为空，则删除S的栈顶元素，用e返回其值，并返回OK,否则返回ERROR
//============运算操作================//
void Standard(char *expression);
//将表达式标准化
opndElem EvalueateExpression(const char *expression);
//算数表达式求值
Status Isoperator(char c);
//判断c是否是一个操作符
char Precede(char op1,char op2);
//判断op1和op2优先级的高低，返回'&','&','='
opndElem operate(opndElem a,optrElem theta,opndElem b);
//对操作数a，b进行theta运算
const char *getOpnd(const char *c,opndElem *op);
//获得以*c开始的操作数，返回后c为操作符
int main()
opndElem result=0;
char *expression=(char*)malloc(sizeof(char)*BUFFERSIZE);
if(expression==NULL){
printf(&Sorry,memory initialize error.\n&);
printf(&Please input an expression:\n&);
gets(expression);
//printf(&Before standard:%s\n&,expression);
Standard(expression);//标准化
//printf(&Standard expression:%s\n&,expression);
result=EvalueateExpression(expression);
printf(&The result of the expression:%d\n&,result);
//==========操作数栈===========//
Status InitStack_OPND(OpndStack *S){
//构造一个空操作数栈S
S-&base=(opndElem *)malloc(STACK_INIT_SIZE*sizeof(opndElem));
if(!S-&base)//分配失败
printf(&分配内存失败.\n&);
S-&top=S-&
S-&stacksize=STACK_INIT_SIZE;
return OK;
Status GetTop_OPND(OpndStack S,opndElem *e){
//若操作数栈不为空，则用e返回S的栈顶元素，并返回OK；否则返回FALSE
if(S.top==S.base){
printf(&栈为空.\n&);
return FALSE;
*e=*(S.top-1);
return OK;
Status Push_OPND(OpndStack *S,opndElem e){
//插入元素e为新的栈顶元素
if(S-&top-S-&base&=S-&stacksize){//栈已满，追加存储空间
S-&base=(opndElem *)realloc(S-&base,(S-&stacksize+STACKINCREMENT)*sizeof(opndElem));
if(!S-&base)
printf(&重新申请空间失败.\n&);
S-&top=S-&base+S-&//更改栈顶指针
S-&stacksize+=STACKINCREMENT;
*S-&top++=e;
return OK;
Status Pop_OPND(OpndStack *S,opndElem *e){
//若栈S不为空，则删除S的栈顶元素，用e返回其值，并返回OK,否则返回ERROR
if(S-&top==S-&base){//栈为空
printf(&栈为空.\n&);
return ERROR;
*e=*(--S-&top);
return OK;
//==========操作符栈===========//
Status InitStack_OPTR(OptrStack *S){
//构造一个空操作数栈S
S-&base=(optrElem *)malloc(STACK_INIT_SIZE*sizeof(optrElem));
if(!S-&base)//分配失败
printf(&分配内存失败.\n&);
S-&top=S-&
S-&stacksize=STACK_INIT_SIZE;
return OK;
optrElem GetTop_OPTR(OptrStack S){
//若操作数栈不为空，则返回S的栈顶元素，并返回OK；否则返回FALSE
if(S.top==S.base){
printf(&栈为空.\n&);
e=*(S.top-1);
Status Push_OPTR(OptrStack *S,optrElem e){
//插入元素e为新的栈顶元素
if(S-&top-S-&base&=S-&stacksize){//栈已满，追加存储空间
S-&base=(optrElem *)realloc(S-&base,(S-&stacksize+STACKINCREMENT)*sizeof(optrElem));
if(!S-&base)
printf(&重新申请空间失败.\n&);
S-&top=S-&base+S-&//更改栈顶指针
S-&stacksize+=STACKINCREMENT;
*S-&top++=e;
return OK;
Status Pop_OPTR(OptrStack *S,optrElem *e){
//若栈S不为空，则删除S的栈顶元素，用e返回其值，并返回OK,否则返回ERROR
if(S-&top==S-&base){//栈为空
printf(&栈为空.\n&);
return ERROR;
*e=*(--S-&top);
return OK;
//============运算操作================//
opndElem EvalueateExpression(const char *expression){
//对只有四则运算符的算数表达式 expression 求值
//OPTR:操作符栈，OPND:操作数栈
const char *c=
OpndStack OPND;
OptrStack OPTR;
optrElem x,
opndElem a,b,num,
InitStack_OPTR(&OPTR);//初始化操作符栈
InitStack_OPND(&OPND);//初始化操作数栈
Push_OPTR(&OPTR,'#');//首先将匹配符号'#'入栈
while(*c!='#'||GetTop_OPTR(OPTR)!='#'){
//printf(&getchar=%c\n&,*c);
if(*c=='\0')//遇到回车退出
if(FALSE==Isoperator(*c)){
c=getOpnd(c,&num);
Push_OPND(&OPND,num);
switch(Precede(GetTop_OPTR(OPTR),*c)){
Push_OPTR(&OPTR,*c);
Pop_OPTR(&OPTR,&x);
Pop_OPTR(&OPTR,&theta);
Pop_OPND(&OPND,&b);
Pop_OPND(&OPND,&a);
result=operate(a,theta,b);
//printf(&temp result is:%d\n&,result);
Push_OPND(&OPND,result);
//printf(&Precede:%c&,Precede(GetTop_OPTR(OPTR),*c));
GetTop_OPND(OPND,&result);
void Standard(char *expression){
//将字符串表达式标准化为算术表达式
char *p=expression,*q;
while(*p!='\0'){//遍历字符串
if(*p==' '){//如果是空格，删除
*q=*(q+1);
}while(*q!='\0');
const char *getOpnd(const char *c,opndElem *op){
//获得以*c开始的操作数，返回后c为操作符
int sum=0,
while(FALSE==Isoperator(*c)){//当c不是操作符
tmp=*c-'0';
sum=sum*10+
//printf(&tmp=%d\n&,tmp);
//printf(&getOpnd:%d\n&,*op);
Status Isoperator(char c){
//判断c是否是一个运算操作符
switch(c){
return TRUE;
return FALSE;
char Precede(char op1,char op2){
//判断op1和op2优先级的高低，返回'&','&','='
switch(op1){
switch(op2){
return '&';
return '&';
switch(op2){
return '&';
return '&';
switch(op2){
return '&';
return '&';
switch(op2){
return '&';
return '&';
switch(op2){
return '=';
return '&';
switch(op2){
return '&';
switch(op2){
return '=';
return '&';
return '&';
opndElem operate(opndElem a,optrElem theta,opndElem b){
//对操作数a，b进行theta运算，并返回运算结果
//theta只能是四则运算符号
switch(theta){
printf(&errror:除数为0.&);
printf(&Is not a operator.\n&);
printf(&%d %c %d = %d\n&,a,theta,b,rs_i);
return rs_i;
运行结果演示：
版权声明：本文为博主原创文章，未经博主允许不得转载。
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：130712次
积分：1671
积分：1671
排名：第12349名
原创：40篇
评论：43条
(2)(1)(2)(2)(1)(1)(1)(2)(2)(1)(6)(1)(12)(3)(1)(1)(1)laokaddk 的BLOG
用户名：laokaddk
文章数：983
评论数：94
访问量：1651268
注册日期：
阅读量：4269
阅读量：1741
阅读量：10158
阅读量：778
51CTO推荐博文
lua与C交互中的堆栈详解
&&& 当在Lua和C之间交换数据时我们面临着两个问题：动态与静态类型系统的不匹配和自动与手动内存管理的不一致。
&&& 在Lua中，我们写下a[k]=v时，k和v可以有几种不同的类型（由于metatables的存在，a也可能有不同的类型）。如果我们想在C中提供类似的操作，无论怎样，操作表的函数(settable)必定有一个固定的类型。我们将需要几十个不同的函数来完成这一个的操作（三个参数的类型的每一种组合都需要一个函数）。
我们可以在C中声明一些union类型来解决这个问题，我们称之为lua_Value，它能够描述所有类型的Lua值。然后，我们就可以这样声明settable
&&& void lua_settable (lua_Value a, lua_Value k, lua_Value v);
&&& 这个解决方案有两个缺点。第一，要将如此复杂的类型映射到其它语言可能很困难；Lua不仅被设计为与C/C++易于交互，Java,Fortran以及类似的语言也一样。第二，Lua负责垃圾回收：如果我们将Lua值保存在C变量中，Lua引擎没有办法了解这种用法；它可能错误地认为某个值为垃圾并收集他。
&&& 因此，Lua API没有定义任何类似lua_Value的类型。替代的方案，它用一个抽象的栈在Lua与C之间交换值。栈中的每一条记录都可以保存任何Lua值。无论你何时想要从Lua请求一个值（比如一个全局变量的值），调用Lua，被请求的值将会被压入栈。无论你何时想要传递一个值给Lua，首先将这个值压入栈，然后调用Lua（这个值将被弹出）。我们仍然需要一个不同的函数将每种C类型压入栈和一个不同函数从栈上取值（译注：只是取出不是弹出），但是我们避免了组合式的爆炸（combinatorial explosion）。另外，因为栈是由Lua来管理的，垃圾回收器知道那个值正在被C使用。几乎所有的API函数都用到了栈。正如我们在第一个例子中所看到的，luaL_loadbuffer把它的结果留在了栈上（被编译的chunk或一条错误信息）；lua_pcall从栈上获取要被调用的函数并把任何临时的错误信息放在这里。
&&& Lua以一个严格的LIFO规则（后进先出；也就是说，始终存取栈顶）来操作栈。当你调用Lua时，它只会改变栈顶部分。你的Ｃ代码却有更多的自由；更明确的来讲，你可以查询栈上的任何元素，甚至是在任何一个位置插入和删除元素。
1.1 压入元素
&&&&API有一系列压栈的函数，它将每种可以用C来描述的Lua类型压栈：空值（nil）用lua_pushnil，数值型（double）用lua_pushnumber，布尔型（在C中用整数表示）用lua_pushboolean，任意的字符串（char*类型，允许包含&字符）用lua_pushlstring，C语言风格（以&结束）的字符串（const char*）用lua_pushstring：
&&& void lua_pushnil (lua_State *L);
&&& void lua_pushboolean (lua_State *L, int bool);
&&& void lua_pushnumber (lua_State *L, double n);
&&& void lua_pushlstring (lua_State *L, const char *s, size_t length);
&&& void lua_pushstring (lua_State *L, const char *s);
&&& 同样也有将C函数和userdata值压入栈的函数，稍后会讨论到它们。
&&& Lua中的字符串不是以零为结束符的；它们依赖于一个明确的长度，因此可以包含任意的二进制数据。将字符串压入串的正式函数是lua_pushlstring，它要求一个明确的长度作为参数。对于以零结束的字符串，你可以用lua_pushstring（它用strlen来计算字符串长度）。Lua从来不保持一个指向外部字符串（或任何其它对象，除了C函数&&它总是静态指针）的指针。对于它保持的所有字符串，Lua要么做一份内部的拷贝要么重新利用已经存在的字符串。因此，一旦这些函数返回之后你可以自由的修改或是释放你的缓冲区。
&&& 无论你何时压入一个元素到栈上，你有责任确保在栈上有空间来做这件事情。记住，你现在是C程序员；Lua不会宠着你。当Lua在起始以及在Lua调用C的时候，栈上至少有20个空闲的记录（lua.h中的LUA_MINSTACK宏定义了这个常量）。对于多数普通的用法栈是足够的，所以通常我们不必去考虑它。无论如何，有些任务或许需要更多的栈空间（如，调用一个不定参数数目的函数）。在这种情况下，或许你需要调用下面这个函数：
&&& int lua_checkstack (lua_State *L, int sz);
&&& 它检测栈上是否有足够你需要的空间（稍后会有关于它更多的信息）。
1.2 查询元素
&&& API用索引来访问栈中的元素。在栈中的第一个元素（也就是第一个被压入栈的）有索引1，下一个有索引2，以此类推。我们也可以用栈顶作为参照来存取元素，利用负索引。在这种情况下，-1指出栈顶元素（也就是最后被压入的），-2指出它的前一个元素，以此类推。例如，调用lua_tostring(L, -1)以字符串的形式返回栈顶的值。我们下面将看到，在某些场合使用正索引访问栈比较方便，另外一些情况下，使用负索引访问栈更方便。
&&& API提供了一套lua_is*函数来检查一个元素是否是一个指定的类型，*可以是任何Lua类型。因此有lua_isnumber,lua_isstring,lua_istable以及类似的函数。所有这些函数都有同样的原型：
int lua_is& (lua_State *L, int index);
&&& lua_isnumber和lua_isstring函数不检查这个值是否是指定的类型，而是看它是否能被转换成指定的那种类型。例如，任何数字类型都满足lua_isstring。
&&& 还有一个lua_type函数，它返回栈中元素的类型。（lua_is*中的有些函数实际上是用了这个函数定义的宏）在lua.h头文件中，每种类型都被定义为一个常量：LUA_TNIL、LUA_TBOOLEAN、LUA_TNUMBER、LUA_TSTRING、LUA_TTABLE、LUA_TFUNCTION、LUA_TUSERDATA以及LUA_TTHREAD。这个函数主要被用在与一个switch语句联合使用。当我们需要真正的检查字符串和数字类型时它也是有用的
&&& 为了从栈中获得值，这里有lua_to*函数：
&&& int lua_toboolean (lua_State *L, int index);
&&& double lua_tonumber (lua_State *L, int index);
&&& const char * lua_tostring (lua_State *L, int index);
&&& size_t lua_strlen (lua_State *L, int index);
&&& 即使给定的元素的类型不正确，调用上面这些函数也没有什么问题。在这种情况下，lua_toboolean、lua_tonumber和lua_strlen返回0，其他函数返回NULL。由于ANSI C没有提供有效的可以用来判断错误发生数字值，所以返回的0是没有什么用处的。对于其他函数而言，我们一般不需要使用对应的lua_is*函数：我们只需要调用lua_is*，测试返回结果是否为NULL即可。
&&& Lua_tostring函数返回一个指向字符串的内部拷贝的指针。你不能修改它（使你想起那里有一个const）。只要这个指针对应的值还在栈内，Lua会保证这个指针一直有效。当一个C函数返回后，Lua会清理他的栈，所以，有一个原则：Lua
Lua_string返回的字符串结尾总会有一个字符结束标志0，但是字符串中间也可能包含0，lua_strlen返回字符串的实际长度。特殊情况下，假定栈顶的值是一个字符串，下面的断言(assert)总是有效的：
&&& const char *s = lua_tostring(L, -1);
&&& size_t l = lua_strlen(L, -1);
&&& assert(s[l] == &);
&&& assert(strlen(s) &= l);
3.3 其他堆栈操作
&&& 除开上面所提及的C与堆栈交换值的函数外，API也提供了下列函数来完成通常的堆栈维护工作：
&&& int lua_gettop (lua_State *L);
&&& void lua_settop (lua_State *L, int index);
&&& void lua_pushvalue (lua_State *L, int index);
&&& void lua_remove (lua_State *L, int index);
&&& void lua_insert (lua_State *L, int index);
&&& void lua_replace (lua_State *L, int index);
&&& 函数lua_gettop返回堆栈中的元素个数，它也是栈顶元素的索引。注意一个负数索引-x对应于正数索引gettop-x+1。lua_settop设置栈顶（也就是堆栈中的元素个数）为一个指定的值。如果开始的栈顶高于新的栈顶，顶部的值被丢弃。否则，为了得到指定的大小这个函数压入相应个数的空值（nil）到栈上。特别的，lua_settop(L,0)清空堆栈。你也可以用负数索引作为调用lua_settop的参数；那将会设置栈顶到指定的索引。利用这种技巧，API提供了下面这个宏，它从堆栈中弹出n个元素：
&&& #define lua_pop(L,n) lua_settop(L, -(n)-1)
&&& 函数lua_pushvalue压入堆栈上指定索引的一个抟贝到栈顶；lua_remove移除指定索引位置的元素，并将其上面所有的元素下移来填补这个位置的空白；lua_insert移动栈顶元素到指定索引的位置，并将这个索引位置上面的元素全部上移至栈顶被移动留下的空隔；最后，lua_replace从栈顶弹出元素值并将其设置到指定索引位置，没有任何移动操作。注意到下面的操作对堆栈没有任何影响：
&&& lua_settop(L, -1);
&&& lua_insert(L, -1);
&&& 为了说明这些函数的用法，这里有一个有用的帮助函数，它dump整个堆栈的内容：
&&& static void stackDump (lua_State *L) {
&&&&&&& int top = lua_gettop(L);
&&&&&&& for (i = 1; i &= i++) {
&&&&&&& int t = lua_type(L, i);
&&&&&&& switch (t) {
&&&&&&& case LUA_TSTRING:
&&&&&&&&&&& printf(&`%s&&, lua_tostring(L, i));
&&&&&&&&&&&
&&&&&&& case LUA_TBOOLEAN:
&&&&&&&&&&& printf(lua_toboolean(L, i) ? &true& : &false&);
&&&&&&&&&&&
&&&&&&& case LUA_TNUMBER:
&&&&&&&&&&& printf(&%g&, lua_tonumber(L, i));
&&&&&&&&&&&
&&&&&&& default:
&&&&&&&&&&& printf(&%s&, lua_typename(L, t));
&&&&&&&&&&&
&&&&&&& printf(& &);
&&& printf(&\n&);
&&& 这个函数从栈底到栈顶遍历了整个堆栈，依照每个元素自己的类型打印出其值。它用引号输出字符串；以%g的格式输出数字；对于其它值（table，函数，等等）它仅仅输出它们的类型（lua_typename转换一个类型码到类型名）。
&&& 下面的函数利用stackDump更进一步的说明了API堆栈的操作。
static void stackDump (lua_State *L) {
int main (void) {
&&& lua_State *L = lua_open();
&&& lua_pushboolean(L, 1);
&&& lua_pushnumber(L, 10);
&&& lua_pushnil(L); lua_pushstring(L, &hello&);
&&& stackDump(L);
&&& lua_pushvalue(L, -4);
&&& stackDump(L);
&&& lua_replace(L, 3);
&&& stackDump(L);
&&& lua_settop(L, 6);
&&& stackDump(L);
&&& lua_remove(L, -3);
&&& stackDump(L);
&&& lua_settop(L, -5);
&&& stackDump(L);
&&& lua_close(L);
&&& return 0;
了这篇文章
类别：┆阅读(0)┆评论(0)}