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

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

要讲C语言的堆栈,要从计算机的数据内存分配讲起

＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿

| Stack区(数组，指针，结构体，局部变量)

＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿

| Static变量(静态变量,全局变量)

＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿

| Heep区(堆区)

＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿

| 代码段

＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿

从上面示意图中可看出整个内存分配,堆分配是在内存中按块划分,也就是相对与函数malloc,realloc,calloc这3个函数为内存分配函数而且需要手动调用free函数释放资源,否则会造成大量的内存碎片

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

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

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

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

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

＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿＿ ＿＿＿＿＿＿＿＿＿

补充:

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

#include <iostreamh>

#include <stdlibh>

#include <malloch>

#include <stringh>

#include <timeh>

#include <stdioh>

#include <asserth>

/

//基于数组的栈的实现

#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);

}

#include <stdioh>//N皇后问题

#include <

stdlibh

>

#include <stdioh>

#include <

iostreamh

>

#include <

timeh

>

#include <dosh>

#include<malloch>

typedef struct {

int elem;

int length;

int listsize;

}Sqlist;

int InitList(Sqlist & L){//初始化

Lelem=(int )malloc(100sizeof(int));

if(!Lelem)

return 0;

Llength=0;

Llistsize=100;

return 1;

}

int Insert(Sqlist & L,int e){//插入

int m=0,i=0; 

int p=&Lelem[0],j=&Lelem[0];

if(Llength==0)

{ p=e; Llength++;return 1;}

for(i;i<Llength;i++)

if(e>=(p+i))

m=i+1;

for(i=Llength;i>m;i--)

(j+i)=(j+i-1);

Lelem[m]=e;

Llength++;

return 1;

}

void Print(Sqlist &L,int n){//

遍历

打印输出

int k=1,i=0; intp=&Lelem[0];

for(i=0;i<nn;i++,k++){

printf("%d ",(p+i));

if(k==n){k=0;printf("\n");}}

printf("\n\n\n\n\n\n\n");

}

int ReturnK(Sqlist &L,int k){//返回第K个元素的值

intp=&Lelem[0];

return (p+k-1); 

}

void FuK(Sqlist &L,int k,int e){//将第k个元素赋值为e

int p=&Lelem[0];

(p+k-1)=e;

}

int TiaoJian(Sqlist L,int n,int &e){//是否满足皇后问题判断

int b[100];

int m=0,h=2n;

for(int k=0;k<2n;k++) b[k]=0; 

for(int i=1;i<=nn;i++)

if(ReturnK(L,i)==1)

{b[m]=(i-1)/n+1;m++;b[m]=i-(b[m-1]-1)n;m++;}

for(int c=0;c<2n;c++)

if(b[c]==0) {h=c;break;} 

for( c=0;c<h-2;c=c+2)

for(int d=c+2;d<h;d=d+2)

if(b[c]==b[d]||b[c+1]==b[d+1]||b[d+1]-b[c+1]==b[d]-b[c]||b[d+1]-b[c+1]==b[c]-b[d])

return 0;

if(h==2n){

printf("\n\n%d皇后问题第%d个排列！\n\n",n,e);e++;

}

return 1; 

}

void Trial(Sqlist &L,int i,int n,int &e){//皇后问题

int j;

if(i>n){Print(L,n);}

else for(j=1;j<=n;j++){

FuK(L,ni-n+j,1);

if(TiaoJian(L,n,e)==1)

Trial(L,i+1,n,e);

FuK(L,ni-n+j,0);

}

}

void main(){

int k,i=0; 

printf("\n\n请输入要n皇后问题个数：\n");

scanf("%d",&k);

time_t rawtime;

struct tm

 timeinfo;

time ( &rawtime );

timeinfo = localtime ( &rawtime );

Sqlist L1;

InitList(L1); 

for(i=0;i<kk;i++)

Insert(L1,0);

int e=1;

Trial(L1,1,k,e);

printf ( "The current date/time is: %s", asctime (timeinfo) );

time ( &rawtime );

timeinfo = localtime ( &rawtime );

printf ( "The current date/time is: %s", asctime (timeinfo) );

printf("哈哈哈哈\(^o^)/~\n");

system("pause");

}

栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除 *** 作，而在表的后端（rear）进行插入 *** 作，和栈一样，队列是一种 *** 作受限制的线性表。进行插入 *** 作的端称为队尾，进行删除 *** 作的端称为队头。

以上是从数据结构角度来看，从 *** 作系统角度来看，所有的数据结构都是对虚拟内存的 *** 作，堆是堆，栈是栈，栈指的是C语言函数所使用的自动有函数回收的虚拟内存空间，而堆则有 *** 作系统堆管理器来管理的那部分虚拟内存，从C语言角度来看，使用malloc函数动态分配的内存，就是堆内存。

堆是用来申请不连续内存的数据区域，比如链表，地址不连续，而是通过指针串在一起形成一个连续的结构，c语言中用malloc函数申请的内存都在堆上，申请过不用时记得要用free函数释放掉，不然内存泄露。

而栈的速度比堆的快，数组和局部变量都是在栈上分配，效率比较高。

另外还有自由存储区、全局/静态存储区和常量存储区，此处不一一讲解了。

在启动文件里都要设置堆和栈的大小，这样合理的分配才不会造成资源的浪费。假如你代码中使用的链表占用空间比较大，这时你就需要把堆设置大一点。假如你使用的数组比较大，就得把堆设置大一点。最简单的方法可以测试一下栈大小，定义一个很大的数组int a[m]; m足够大时就会栈溢出。

想更多的了解c语言具体内存分区的话去百度吧，就帮你到这里了

以下代码是基于C语言写的堆栈的压栈，出栈，清栈，读栈指针等方法，在Visual studio 中，可直接使用，供学习者参考学习。

#include

#include

#include

#include

#include

#include

#define MAX_SIZE 100

typedef struct Stack

{

char data;

int size;

int top;

};

void initStack(Stack s); //init stack

void destroyStack(Stack s);

bool push(Stack s,char ch);

char pop(Stack s);

char gettop(Stack s);

bool isEmpty(Stack s);

bool isFull(Stack s);

void setNull(Stack s);

#endif

void initStack(Stack s)

{

s->data = (char)malloc(MAX_SIZE sizeof(char)); //分配最大内存空间

if (!s->data)

exit(OVERFLOW); //提前终止程序

s->size = MAX_SIZE;

s->top = -1;

}

void destroyStack(Stack s)

{

free(s->data);

}

bool push(Stack s, char ch)

{

if ((s->top + 1) != s->size)

{

s->data[++s->top] = ch;

return true;

}

else

return false;

}

char pop(Stack s)

{

if (s->top != -1)

return s->data[s->top--];

}

char gettop(Stack s)

{

return s->data[s->top];

}

bool isEmpty(Stack s)

{

if (s->top == -1)

return true;

else

return false;

}

bool isFull(Stack s)

{

if ((s->top + 1) == s->size)

return true;

else

return false;

}

void setNull(Stack s)

{

s->top = -1;

}

int main()

{

char chd;

bool c;

Stack s1;

initStack(&s1);

c = push(&s1, 'a');

printf("Stack s1 push status is %d,sdata is %c,top value is %d ", c,s1data[s1top],s1top);

c = push(&s1, 'b');

printf("Stack s1 push status is %d,sdata is %c,top value is %d ", c, s1data[s1top], s1top);

chd = gettop(&s1);

printf("Stack s1->top data:%c,top value is %d ", chd, s1top);

chd = pop(&s1);

printf("Stack d出 data:%c,top value is %d ", chd, s1top);

chd = pop(&s1);

printf("Stack d出 data:%c,top value is %d ", chd, s1top);

c = isEmpty(&s1);

printf("Stack s1 c bool:%d,top value is %d ", c, s1top);

c = isFull(&s1);

printf("Stack s1 c bool:%d,top value is %d ", c, s1top);

return 0;

}

以上就是关于谁能帮我说下C语言中的堆栈全部的内容，包括:谁能帮我说下C语言中的堆栈、利用《数据结构》课程知识完成C语言程序设计“N皇后问题”（堆栈，一维数组，普通算法都可以，用C语言写、c语言堆栈和队列等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！