程序的执行过程可看作连续的函数调用。当一个函数执行完毕时，程序要回到调用指令的下一条指令(紧接call指令)处继续执行。函数调用过程通常使用堆栈实现，每个用户态进程对应一个调用栈结构(call stack)。编译器使用堆栈传递函数参数、保存返回地址、临时保存寄存器原有值(即函数调用的上下文)以备恢复以及存储本地局部变量。
成都创新互联公司专注为客户提供全方位的互联网综合服务，包含不限于网站设计、网站建设、盐都网络推广、微信平台小程序开发、盐都网络营销、盐都企业策划、盐都品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；成都创新互联公司为所有大学生创业者提供盐都建站搭建服务，24小时服务热线：18980820575，官方网址：www.cdcxhl.com
不同处理器和编译器的堆栈布局、函数调用方法都可能不同，但堆栈的基本概念是一样的。
寄存器是处理器加工数据或运行程序的重要载体，用于存放程序执行中用到的数据和指令。因此函数调用栈的实现与处理器寄存器组密切相关。
AX(AH、AL)：累加器。有些指令约定以AX(或AL)为源或目的寄存器。输入/输出指令必须通过AX或AL实现，例如：端口地址为43H的内容读入CPU的指令为INAL，43H或INAX，43H。目的操作数只能是AL/AX，而不能是其他的寄存器。 [5]
BX(BH、BL)： 基址寄存器 。BX可用作间接寻址的地址寄存器和 基地址寄存器 ，BH、BL可用作8位通用数据寄存器。 [5]
CX(CH、CL)：计数寄存器。CX在循环和串操作中充当计数器，指令执行后CX内容自动修改，因此称为计数寄存器。 [5]
DX(DH、DL)：数据寄存器。除用作通用寄存器外，在 I/O指令 中可用作端口 地址寄存器 ，乘除指令中用作辅助累加器。 [5]
2.指针和 变址寄存器
BP( Base Pointer Register)：基址指针寄存器。 [5]
SP( Stack Pointer Register)： 堆栈指针寄存器 。 [5]
SI( Source Index Register)：源变址寄存器。 [5]
DI( Destination Index Register)：目的变址寄存器。 [5]
函数调用栈的典型内存布局如下图所示：
图中给出主调函数(caller)和被调函数(callee)的栈帧布局，"m(%ebp)"表示以EBP为基地址、偏移量为m字节的内存空间(中的内容)。该图基于两个假设：第一，函数返回值不是结构体或联合体，否则第一个参数将位于"12(%ebp)" 处；第二，每个参数都是4字节大小(栈的粒度为4字节)。在本文后续章节将就参数的传递和大小问题做进一步的探讨。 此外，函数可以没有参数和局部变量，故图中“Argument(参数)”和“Local Variable(局部变量)”不是函数栈帧结构的必需部分。
其中，主调函数将参数按照调用约定依次入栈(图中为从右到左)，然后将指令指针EIP入栈以保存主调函数的返回地址(下一条待执行指令的地址)。进入被调函数时，被调函数将主调函数的帧基指针EBP入栈，并将主调函数的栈顶指针ESP值赋给被调函数的EBP(作为被调函数的栈底)，接着改变ESP值来为函数局部变量预留空间。此时被调函数帧基指针指向被调函数的栈底。以该地址为基准，向上(栈底方向)可获取主调函数的返回地址、参数值，向下(栈顶方向)能获取被调函数的局部变量值，而该地址处又存放着上一层主调函数的帧基指针值。本级调用结束后，将EBP指针值赋给ESP，使ESP再次指向被调函数栈底以释放局部变量；再将已压栈的主调函数帧基指针弹出到EBP，并弹出返回地址到EIP。ESP继续上移越过参数，最终回到函数调用前的状态，即恢复原来主调函数的栈帧。如此递归便形成函数调用栈。
EBP指针在当前函数运行过程中(未调用其他函数时)保持不变。在函数调用前，ESP指针指向栈顶地址，也是栈底地址。在函数完成现场保护之类的初始化工作后，ESP会始终指向当前函数栈帧的栈顶，此时，若
给你个例子：
#include
//写好加法，以便调用
int sum(int x1,int x2)
{
int x3=x1+x2;
return x3;
}
void main()
{
int a=0;
int b=0;
int c=0;
printf("请输入两个整数\n");
scanf("%d%d",a,b);
c=sum(a,b);//传递参数给sum（）函数，返回他们的和
printf("%d+%d的和是：%d\n",a,b,c);
}
总之：就是你把一种方法写到单独的块，这里就是sum()函数，执行一个单一的功能，在main函数调用就是了！
//顺序栈
#include
#include
#include
#define
STACK_INIT_SIZE
100;
#define
STACKINCREMENT
10;
typedef
struct
{
int
*base;
int
*top;
int
stacksize;
}SqStack;
typedef
int
ElemType;
int
InitStack(SqStack
S)
//为栈S分配存储空间，并置S为空栈
{
int
size
=
STACK_INIT_SIZE;
S.base=(int
*)malloc(size*sizeof(ElemType));
if(!S.base)
return
0;
S.top=S.base;
//置栈S为空栈
S.stacksize=STACK_INIT_SIZE;
return
1;
}
int
GetTop(SqStack
S,int
e)
//若栈不空，则用e返回S的栈顶元素
{
if(S.top==S.base)
return
0;
e=*(S.top-1);
return
1;
}
int
Push(SqStack
S,
int
e)
/*进栈函数,将e插入栈S中,并使之成为栈顶元素*/
{
if(S.top-S.base=S.stacksize)
/*栈满，追加存储空间*/
{
int
stackinvrement
=
STACKINCREMENT;
S.base=(ElemType
*)
realloc(S.base,(S.stacksize+stackinvrement)*sizeof(ElemType));
if(!S.base)
return
0;
/*存储分配失败*/
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return
1;
}
int
Pop(SqStack
S,int
e)/*出栈函数,若栈S不空,则删除S的栈顶元素,用e返回其值*/
{
if(S.top==S.base)
return
0;
e=*--S.top;
return
1;
}
void
OutputStack(SqStack
S)
{int
*q;
q=S.top-1;
for(int
i=0;i
#include
typedef
struct
SNode
{
int
data;
struct
SNode
*next;
}SNode,*LinkStack;
LinkStack
top;
LinkStack
PushStack(LinkStack
top,int
x)
//入栈
{
LinkStack
s;
s=(LinkStack)malloc(sizeof(SNode));
s-data=x;
s-next=top;
top=s;
return
top;
}
LinkStack
PopStack(LinkStack
top)
//退栈
{
LinkStack
p;
if(top!=NULL)
{
p=top;
top=top-next;
free(p);
printf("退栈已完成\n");
return
top;
}
else
printf("栈是空的，无法退栈！\n");
return
0;
}
int
GetStackTop(LinkStack
top)
//取栈顶元素
{
return
top-data;
}
bool
IsEmpty()//bool取值false和true，是0和1的区别,bool只有一个字节,BOOL为int型,bool为布尔型
{
return
top==NULL
?
true:false;
}
void
Print()
{
SNode
*p;
p=top;
if(IsEmpty())
{
printf("The
stack
is
empty!\n");
return;
}
while(p)
{
printf("%d
",
p-data);
p=p-next;
}
printf("\n");
}
void
main()
{
int
x,a,b;
char
m;
do
{
printf("\n");
printf("###############链栈的基本操作##################\n");
printf("××××××××1.置空栈××××××××××\n");
printf("××××××××2.进栈×××××××××××\n");
printf("××××××××3.退栈×××××××××××\n");
printf("××××××××4.取栈顶元素××××××××\n");
printf("××××××××5.退出程序×××××××××\n");
printf("##############################################\n");
printf("\n请选择一个字符:");
scanf("%c",m);
switch(m){
case
'1':
top=NULL;
printf("\n栈已置空!");
break;
case
'2':
printf("\n请输入要进栈的元素个数是:");
scanf("%d",a);
printf("\n请输入要进栈的%d个元素:",a);
for(b=0;b
评论
加载更多
#include
#include
#define Max 100
typedef char T;
typedef struct MyStack
{
T aa[Max];
unsigned int p;
} stack;
//创建空栈
stack* createEmptyStack()
{
stack* st = (stack *)malloc(sizeof(stack));
int i=0;
for(i=0;iMax;i++)
st-aa[i]=0;
st-p=0;
return st;
};
//栈判空
int isEmpty(const stack* st)
{
if(st-p==0) return 1;
else return 0;
};
//求栈的大小
unsigned int size(const stack* st)
{
return st-p;
};
//push操作
void push(stack* st,const T a)
{
st-p=st-p+1;
if(st-p==Max)
{
printf("栈满\n");
st-p--;
return;
}
st-aa[st-p]=a;
};
//pop操作
T pop(stack* st)
{
if(isEmpty(st))
{
printf("栈空");
return NULL;
}
char t=st-aa[st-p];
st-p=st-p-1;
printf("%c ",t);
return t;
};
//栈销毁
void destroy(stack* st)
{
free(st);
};
int main()
{
stack* st = createEmptyStack();
if(isEmpty(st)) printf("MyStack is empty\n");
else printf("MyStack is not empty\n");
push(st,'a');
push(st,'b');
push(st,'c');
push(st,'d');
push(st,'e');
printf("%d\n",size(st));
while(!isEmpty(st)) pop(st);
destroy(st);
system("pause");
return 0;
}
栈简单的讲就是一片存储区域（存储区的首地址即为栈顶）
你可以向栈中存入数据取出数据删除数据
/*
Note:Your
choice
is
C
IDE
*/
#include
"stdio.h"
#define
m
100
struct
Mystack/*定义栈结构*/
{
char
element[m];
int
top;/*栈顶*/
};
void
push(struct
Mystack
*s,char
x)
/*将x的值压入栈顶*/
{
/*
s-element[s-top]=x;
s-top++;*/
s-element[s-top]=x;
s-top++;
}
void
pop(struct
Mystack
*s)
/*将栈顶元素删除*/
{
s-top--;
}
int
IsEmpty(struct
Mystack
*s)
/*判断栈是否为空*/
{
if(s-top==0)
return
1;
else
return
0;
}
void
Clearstack(struct
Mystack
*s)
/*清空栈元素*/
{
s-top=0;
}
void
Displaystack(struct
Mystack
*s)
/*输出栈元素*/
{
int
i;
for(i=0;i
top;i++)
printf("%c",s-element[i]);
}
main()
{
struct
Mystack
st;
int
i;
char
ch;
for(i=0;i100;i++)
st.element[i]='\0';
st.top=0;
printf("please
write
a
string:\n");
ch=getchar();
while(ch!='\n')
{
switch(ch)
{
case
'#':
if(!IsEmpty(st))
pop(st);
break;
case
'@':
if(!IsEmpty(st))
Clearstack(st);
break;
default:
push(st,ch);
}
ch=getchar();
}
printf("the
string
is
:\n");
Displaystack(st);
}
写了一个链式栈，你看看
# include stdio.h
# include malloc.h
# include stdlib.h
typedef struct Node
{
int data;
struct Node *pNext;
}NODE, *PNODE;
typedef struct Stack
{
PNODE pTop;
PNODE pBottom;//pBottem是指向栈底下一个没有实际意义的元素
}STACK, *PSTACK;
void init( PSTACK );
void push( PSTACK, int );
void traverse( PSTACK );
int pop( PSTACK, int * );
int empty( PSTACK pS );
int main( void )
{
STACK S;//STACK等价于struct Stack
int val;
init( S );//目的是造出一个空栈
push( S, 1 );//压栈
push( S, 2 );
push( S, 3 );
push( S, 4 );
push( S, 5 );
push( S, 6 );
push( S, 7 );
traverse( S );//遍历输出
// clear( S ); //清空数据
// traverse( S );//遍历输出
if( pop( S, val ) )
{
printf( "出栈成功,出栈的元素是%d\n", val );
}
else
{
printf( "出栈失败" );
}
traverse( S );//遍历输出出栈之后的元素
return 0;
}
void init( PSTACK pS )
{
pS-pTop = ( PNODE )malloc( sizeof( NODE ) );
if( NULL == pS-pTop )
{
printf( "动态内存分配失败!\n" );
exit( -1 );
}
else
{
pS-pBottom = pS-pTop;
pS-pTop-pNext = NULL;//或是pS-pBottom = NULL;
}
}
void push( PSTACK pS, int val )
{
PNODE pNew = ( PNODE )malloc( sizeof( NODE ) );
pNew-data = val;
pNew-pNext = pS-pTop;//pS-Top不能改为pS-pBottom
pS-pTop = pNew;
}
void traverse( PSTACK pS )
{
PNODE p = pS-pTop;
while( p != pS-pBottom )
{
printf( "%d ", p-data );
p = p-pNext;
}
printf( "\n" );
}
int empty( PSTACK pS )
{
if( pS-pTop == pS-pBottom )
return 1;
else
return 0;
}
//把pS所指向的栈出栈一次,并把出栈的元素存入pVal形参所指向的变量中,如果出栈失败,则返回false,否则true
int pop( PSTACK pS, int *pVal)
{
if( empty( pS ) )//pS本身存放的就是S的地址
{
return 0;
}
else
{
PNODE r = pS-pTop;
*pVal = r-data;
pS-pTop = r-pNext;
free( r );
r = NULL; //为什么要把r赋给NULL呢??
return 1;
}
}
//clear清空
void clear( PSTACK pS )
{
if( empty( pS ) )
{
return ;
}
else
{
PNODE p = pS-pTop;
PNODE q = p-pNext;
while( p != pS-pBottom )
{
q = p-pNext;
free( p );
p = q;
}
pS-pTop = pS-pBottom;
}
}
