c语言数组堆栈

Ⅰ c语言数组什么是防止堆栈溢出

inc返回的是数组a第一个元素的地址，也就是说指针b被赋值成数组a第一个元素的地址，也指向数组a,并没有分配新的内存，a和b指向的是同一个数组。如果需要分配新的内存，可以使用malloc。
b
=
(u8
*)
malloc(8
*
sizeof(u8));
//
动态分配8个大小为u8的空间

Ⅱ c语言数组在内存中是怎么分配的

C语言中内存为分三类：栈区、堆区、静态数据区。

局部变量在栈上分配，函数调用前的栈指针，要和函数返回后的栈指针一样，否则就会出错。

void test(void)

{

char i,a[10];

printf("0x%x", &i);

printf("0x%x", a);

printf("0x%x", a+1);

printf("0x%x", a+2);

printf("0x%x", a+3);

}

(2)c语言数组堆栈扩展阅读

c语言数组在内存分配

示例：

#include<stdio.h>

int main()

{

int a[4] = {11,12,13,14};

int b[4] = {21,22,23,24};

int *pa = &a;

int i = 0;

while(i<8)

{

i++;

printf("now *p value = %d and",*pa);

printf("p addr value = %d ",pa);

pa++;

}

return 0;

}

Ⅲ C语言堆栈问题，数组作为函数参数到底是占用堆空间还是栈空间啊

你这个函数只传了一个数组的地址，说白了就是一个unsigned long int数，就一个这样的数你觉得用得着去动用栈栈传参吗？X86随便一个寄存器都能装得下，一般AX，BX,CX,DX这几个寄存器对于这种传几个字长的参数够够的了，只有在寄存器不够的情况下，参数过多，或参数过大（结构体）才用得着堆栈传参。另外提醒一下：你这个N是传不进来的，编译器只是根据[ ]这个符号来认定array是一个地址，N只能另外做为一个int N 的参数传进来。

Ⅳ 怎么用C语言编写堆栈并能进行四则运算

3个文件，按您的要求
头文件H
＃IFNDEF _XXXX_H
＃定义_XXXX_H
＃定义错误-1
＃定义MAX 100 / *定义堆栈的大小* /
静态int堆栈[MAX]; / *定义一个一维数组堆栈* /
静态int top = 0的; / *自定义堆栈指令* /

诠释推（int i）的;
的pop（）;

＃ENDIF / * _XXXX_H * /

功能文件CPP
＃包括“xxxx.h”的

诠释推（I）/ *内存操作数栈操作* /
{
？？（顶部<MAX）
？？？
？？？？栈[+ +顶部] = I / *栈，仍然有空间的堆栈顶部的表示移动一个位置* /
？？？？返回0;
？？}
？？其他
？？？
？？？？printf的（“堆栈满了”）;
？？？？返回错误;
？？}
}
POP（）/ *删除的操作数，并弹出操作* /
{
？？VAR; / *定义要返回的顶级元素* /
？？如果（top! = NULL）/ *仍然堆放元素* /
？？？
？？？？VAR =栈[ - ] / *堆栈指针向下移动一个位置* /
？？？？返回VAR / *返回的顶部堆栈元素* /
？？}
？？其他
？？？？printf的（“堆栈是空的！\ n”）;
？？返回错误;
}

主文件CPP
＃包括<stdio.h>
＃包括<conio.h>
＃包括<stdlib.h>
＃包括“xxxx.h”的
无效的主要（）
{
？？INT M，N;
？？字符L;
？？整数A，B，C;
？？整数K;
？？{
？？？？输出（“\ n \ n \ t单击以下提示输入你需要的信息\ n”）;
？？？？输出（“\ n \问你输入第二个捣弄数字”）;
？？？？scanf的（“％d”，＆M）;
？？？？推（M）/ *第一个操作数堆栈* /
？？？？输出（“\ n \问你输入第二个捣弄数字”）;
？？？？scanf的（“％d”，＆N）;
？？？？推（N）; / *第二个操作数堆栈* /
？？？？输出（“\ n \你不想算术运算（+ / - / * / /）：”）;
？？？？L = getche（）; / *输入操作符* /
？？？？开关（L）/ *确定的运营商，依次执行代码* /
？？？？
？？？？？？'+'：
？？？？？？？？= pop（）方法;
？？？？？？？？= pop（）方法;
？？？？？？？？C = A + B;
？？？？？？？？输出（“\ n \ n \ t计算公式为：％d条\ n”，c）;
？？？？？？？？输出（“\ n”）;
？？？？？？？？;
？？？？？？情况下，' - '：
？？？？？？？？= pop（）方法;
？？？？？？？？= pop（）方法;
？？？？？？？？C = A-B;
？？？？？？？？输出（“\ n \ n \ t计算公式为：％d条\ n”，c）;
？？？？？？？？输出（“\ n”）;
？？？？？？？？;
？？？？？？情况下，'*'：
？？？？？？？？= pop（）方法;
？？？？？？？？= pop（）方法;
？？？？？？？？C = A * B;
？？？？？？？？输出（“\ n \ n \ t计算公式为：％d条\ n”，c）;
？？？？？？？？输出（“\ n”）;
？？？？？？？？;
？？？？？？情况下，'/'：
？？？？？？？？= pop（）方法;
？？？？？？？？= pop（）方法;
？？？？？？？？C = A / B;
？？？？？？？？输出（“\ n \ n \ t计算公式为：％d条\ n”，c）;
？？？？？？？？输出（“\ n”）;
？？？？？？？？;
？？？？}
？？？？输出（“\ t要继续输入计算吗？（Y / N）：”）; / *提示用户是否在程序结束* /
？？？？L = getche（）;
？？？？（L =='N'）
？？？？？？退出（0）;
？？}（1）;
}

Ⅳ C语言中的栈、堆是什么

C语言中的堆和栈都是一种数据项按序排列的数据结构。

栈就像装数据的桶或箱子

我们先从大家比较熟悉的栈说起吧，它是一种具有后进先出性质的数据结构，也就是说后存放的先取，先存放的后取。

这就如同我们要取出放在箱子里面底下的东西（放入的比较早的物体），我们首先要移开压在它上面的物体（放入的比较晚的物体）。

堆像一棵倒过来的树

而堆就不同了，堆是一种经过排序的树形数据结构，每个结点都有一个值。

通常我们所说的堆的数据结构，是指二叉堆。堆的特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。

由于堆的这个特性，常用来实现优先队列，堆的存取是随意，这就如同我们在图书馆的书架上取书。

虽然书的摆放是有顺序的，但是我们想取任意一本时不必像栈一样，先取出前面所有的书，书架这种机制不同于箱子，我们可以直接取出我们想要的书。

(5)c语言数组堆栈扩展阅读：

关于堆和栈区别的比喻

使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。

使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

参考资料来源：网络-堆栈

Ⅵ 一个C语言堆栈的问题

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedefstruct
{
	chardata[50];
	inttop;
}seqstack;

main()
{	
	chara[50]={0};
	inti;
	seqstack*s=(seqstack*)malloc(sizeof(seqstack));
	s->top=-1;
	scanf("%s",a);
	for(i=0;i<strlen(a);i++)
		if(a[i]=='(')
		{
			s->top++;
			s->data[s->top]='(';
		}
		elseif(a[i]==')')
		{
			if(s->top<0)
			{
				printf("underflow");
				break;
			}
			else
			{
				if(s->data[s->top--]!='('){
					printf("error");
					break;
				}
			}
		}
	if(s->top==-1)printf("correct");
	elseprintf("error");
	return0;
}

Ⅶ 关于C语言堆栈的问题！

C语言中堆栈说的是数据结构，和系统中的堆栈中是不一样的，/*
**用一个静态数组实现的堆栈。数组的长度只能通过修改#define的定义
**并对模块重新进行编译
*/#include"stack.h"
#include<assert.h>#define STACK_SIZE 100 /*堆栈中值数量的最大限制*//*
**存储堆栈中值的数组和一个指向堆栈顶部元素的指针
*/
static STACK_TYPE stack[STACK_SIZE];
static int top_element =-1;/*push*/
void push(STACK_TYPE value)
{
assert(!is_full());
top_element +=1;
stack[top_element]=value;
}/*pop*/
STACK_TYPE pop(void)
{
STACK_TYPE temp;
assert(!is_empty());
temp=stack[top_element];
top_element -= 1;
return temp;
}/*top*/
STACK_TYPE top (void)
{
assert(!is_empty());
return stack[top_element];
}/*
** is _empty
*/
int is_empty(void)
{
return top_element == -1;
}/*
**is_full
*/
int is_full(void)
{
return top_element ==STACK_SIZE -1;
}这是个静态堆栈，你可以动态的申请内存来编写动态堆栈

Ⅷ 谁能帮我说下C语言中的堆栈

个人认为楼上的不懂C语言堆栈到底是怎么回事,按楼上说法,只是大概讲了下栈,没有讲堆.

要讲C语言的堆栈,要从计算机的数据内存分配讲起.
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
| Stack区(数组，指针，结构体，局部变量)
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
| Static变量(静态变量,全局变量)
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
| Heep区(堆区)
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
| 代码段
＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿
从上面示意图中可看出整个内存分配,堆分配是在内存中按块划分,也就是相对与函数malloc,realloc,calloc.这3个函数为内存分配函数.而且需要手动调用free函数释放资源,否则会造成大量的内存碎片.

如果楼主不相信可以自己写一个死循环,内部调用malloc函数,创建N个内存块,运行一段时间后,绝对会造成系统瘫痪,资源被耗尽.

栈区划分为计算机自身划分,即在函数或局部变量被调用时,系统自动为其分配栈,以后进先出为原则实现变量的保存,在函数调用完毕时,系统会自动释放栈内资源,所以,栈可以说是短命的(生存周期只在调用过程中).

这里只是粗略说了下堆和栈,另外再说下static-->静态区,全局变量或静态变量存放于静态区,只要代码中存在静态变量或全局变量,自动放于静态区,静态区存放的变量生存周期是整个程序结束时才释放.

代码段区,顾名思义存放的是程序代码(暂时先这么理解).

PS:本人原创,最近发现一些人盗用本人回答的问题.特此声明.嘿嘿.

＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿ ＿＿＿＿＿＿＿＿＿
补充:
我对于C#不是很熟悉,而且我也是从事C开发的,对于面向对象语言应用不是很熟.在这只能给出C++的代码.代码有点长,不知道你能不能看的懂,才写的.

#include <iostream.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#include <time.h>
#include <stdio.h>
#include <assert.h>
/*
//基于数组的栈的实现
#define N 50
typedef struct Stack{
int top;
int A[N];
}*pStack;
//Pop出栈
int Pop(pStack pst)
{
int e;
if(pst->top == -1)
{
cout<<"Stack is empty!"<<endl;
return -1;
}
else
{
e = pst->A[pst->top];
pst->top--;
// cout<<"The element "<<e<<" is pop"<<endl;
return e;
}
}
//Push入栈
void Push(pStack pst)
{
int e;
if(pst->top == N-1)
{
cout<<"Stack is full!"<<endl;
}
else
{
cout<<"Input the push number:";
cin>>e;
pst->top++;
pst->A[pst->top] = e;
}
}
//清空栈
void empty(pStack pst)
{
pst->top = -1;
}
//判断栈是否为空
int IsEmpty(pStack pst)
{
if(pst->top == -1)
{
return 0;
// cout<<"The Stack is empty!"<<endl;
}
else
{
return 1;
// cout<<"The Stack is not empty!"<<endl;
}
}
//判断栈是否为满
int IsFull(pStack pst)
{
if(pst->top == N-1)
{
return 0;
}
else
{
return 1;
}
}
//初始化栈
void InitStack(pStack pst)
{
pst->top = -1;
}

void main()
{
Stack S;
InitStack(&S);
int n;
cout<<"How many times do you want to Push:";
cin>>n;
for(int i=0; i<n; i++)
{
Push(&S);
}
cout<<"How many times do you want to Pop:";
cin>>n;
for(i=0; i<n; i++)
{
cout<<"The element "<<Pop(&S)<<" is pop"<<endl;
}
cout<<"The Stack's stutor:"<<endl;

if(IsEmpty(&S) == 0)
{
cout<<"The Stack is empty!"<<endl;
}
else
{
cout<<"The Stack is not empty!"<<endl;
}

if(IsFull(&S) == 0)
{
cout<<"The Stack is full!"<<endl;
}
else
{
cout<<"The Stack is not full!"<<endl;
}

empty(&S);

cout<<"The Stack's stutor:"<<endl;
if(IsEmpty(&S) == 0)
{
cout<<"The Stack is empty!"<<endl;
}
else
{
cout<<"The Stack is not empty!"<<endl;
}
}
*/
typedef struct Stack{
Stack *prior;
Stack *next;
int element;
}*pStack;
//压栈
void Push(pStack *pst)
{
if((*pst) == NULL)
{
pStack S = (pStack)malloc(sizeof(Stack));
(*pst) = S;
(*pst)->next = NULL;
(*pst)->prior = NULL;
cout<<"Input the PUSH data:";
cin>>(*pst)->element;
}
else
{
pStack S = (pStack)malloc(sizeof(Stack));
(*pst)->next = S;
S->prior = (*pst);
S->next = NULL;
(*pst) = S;
cout<<"Input the PUSH data:";
cin>>(*pst)->element;
}
}
//判断是否为空
int IsEmpty(pStack pst)
{
if(pst == NULL)
{
cout<<"The Stack is empty!"<<endl;
return 1;
}
return 0;
}
//出栈
pStack Pop(pStack *pst)
{
if(IsEmpty((*pst)) == 1)
return (*pst);
pStack S = (*pst);
if((*pst)->prior == NULL)
{
cout<<"Out:"<<(*pst)->element<<endl;
(*pst) = NULL;
free(S);
return (*pst);
}
else
{
cout<<"Out:"<<(*pst)->element<<endl;
(*pst) = (*pst)->prior;
(*pst)->next = NULL;
free(S);
return (*pst);
}
}
//初始化栈
void InitStack(pStack pst)
{
pst = NULL;
}

void main()
{
pStack pS = NULL;
// InitStack(pS);
int n;
cout<<"How many times do you want to Push:";
cin>>n;
for(int i=0; i<n; i++)
{
Push(&pS);
}
pStack S;
S = Pop(&pS);
}

Ⅸ c语言的堆栈是怎么回事！！

堆(heap)和栈(stack)有什么区别??

简单的可以理解为：
heap：是由malloc之类函数分配的空间所在地。地址是由低向高增长的。
stack：是自动分配变量，以及函数调用的时候所使用的一些空间。地址是由高向低减少的。

预备知识—程序的内存分配

一个由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在常量区，p3在栈上。
static int c =0； 全局（静态）初始化区
p1 = (char *)malloc(10);
p2 = (char *)malloc(20);
分配得来得10和20字节的区域就在堆区。
strcpy(p1, "123456"); 123456放在常量区，编译器可能会将它与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小结：
堆和栈的区别可以用如下的比喻来看出：
使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。
使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

堆和栈的区别主要分：
操作系统方面的堆和栈，如上面说的那些，不多说了。
还有就是数据结构方面的堆和栈，这些都是不同的概念。这里的堆实际上指的就是（满足堆性质的）优先队列的一种数据结构，第1个元素有最高的优先权；栈实际上就是满足先进后出的性质的数学或数据结构。
虽然堆栈，堆栈的说法是连起来叫，但是他们还是有很大区别的，连着叫只是由于历史的原因针值读

Ⅹ 数组堆栈c语言编码

#include <stdio.h>#include <stdlib.h>#define Size 20 typedef char ElementType;typedef struct{ ElementType data[Size]; int top;}Stack; int StackFull(Stack *s){ return (s->top==Size-1);} void PushStack(Stack *s, char *buf){ if(NULL==s || NULL==buf) return; while( *buf!='\0' && *buf!='^' && !StackFull(s)) { if(*buf != ' ') s->data[++s->top] = *buf; ++buf; }} void PopStack(Stack *s){ if(NULL == s) return; while(s->top != -1) putchar(s->data[s->top--]);} int main(){ char str[Size]; Stack *s = (Stack*)malloc(sizeof(Stack)); s->top = -1; gets(str); PushStack(s, str); PopStack(s); return 0;}