㈠ c语言版数据结构关于栈的问题，数据压不进去 ，有谁知道怎么回事吗感谢
//给你一个正确的栈操作吧，你的代码真的很难看得明白：无法捉摸到你想干吗。。
#include<stdio.h>
#include<malloc.h>
#defineDataTypeint
#defineMAXSIZE1024
typedefstruct
{
DataTypedata[MAXSIZE];
inttop;
}SeqStack;
SeqStack*Init_SeqStack()//栈初始化
{
SeqStack*s;
s=(SeqStack*)malloc(sizeof(SeqStack));
if(!s)
{
printf("空间不足 ");
returnNULL;
}
else
{
s->top=-1;
returns;
}
}
intEmpty_SeqStack(SeqStack*s)//判栈空
{
if(s->top==-1)
return1;
else
return0;
}
intPush_SeqStack(SeqStack*s,DataTypex)//入栈
{
if(s->top==MAXSIZE-1)
return0;//栈满不能入栈
else
{
s->top++;
s->data[s->top]=x;
return1;
}
}
intPop_SeqStack(SeqStack*s,DataType*x)//出栈
{
if(Empty_SeqStack(s))
return0;//栈空不能出栈
else
{
*x=s->data[s->top];
s->top--;
return1;
}//栈顶元素存入*x，返回
}
DataTypeTop_SeqStack(SeqStack*s)//取栈顶元素
{
if(Empty_SeqStack(s))
return0;//栈空
else
returns->data[s->top];
}
intPrint_SeqStack(SeqStack*s)
{
inti;
printf("当前栈中的元素: ");
for(i=s->top;i>=0;i--)
printf("%3d",s->data[i]);
printf(" ");
return0;
}
intmain()
{
SeqStack*L;
intn,num,m;
inti;
L=Init_SeqStack();
printf("初始化完成 ");
printf("栈空：%d ",Empty_SeqStack(L));
printf("请输入入栈元素个数： ");
scanf("%d",&n);
printf("请输入要入栈的%d个元素： ",n);
for(i=0;i<n;i++)
{
scanf("%d",&num);
Push_SeqStack(L,num);
}
Print_SeqStack(L);
printf("栈顶元素：%d ",Top_SeqStack(L));
printf("请输入要出栈的元素个数（不能超过%d个）： ",n);
scanf("%d",&n);
printf("依次出栈的%d个元素： ",n);
for(i=0;i<n;i++)
{
Pop_SeqStack(L,&m);
printf("%3d",m);
}
printf(" ");
Print_SeqStack(L);
printf("栈顶元素：%d ",Top_SeqStack(L));
return0;
}
㈡ c语言：函数调用时，栈的问题——（有请高手高手高高手）
必须出栈!
aa 和 bb 和c 都是函数内部的局部变量，函数返回后就被释放，也就是在栈中没有了，返回后就剩下图中main（）函数所对应的栈结构.
栈只能够通过出栈来减少栈中数据的个数,从反面来讲,如果不出栈,funcA()函数返回后,栈指针还是指向c那，这肯定是不对的，因为函数返回后栈指针就得指向man（）的栈结构了。
㈢ 数据结构栈中，数制间的转换问题！
#include
#
define
MAXSIZE
100
typedef
int
ElemType;
typedef
struct
{
ElemType
data[MAXSIZE];
int
top;
}SeqStack;
void
InitStack(SeqStack
*s)
{s->top=0;
}
int
StackEmpty(SeqStack
*s)
{
if(s->top==0)
return
1;
else
return
0;
}
void
Push(SeqStack
*s,int
x){
s->data[s->top]=x;
s->top++;
}
ElemType
Pop(SeqStack
*s)
{
ElemType
y;
y=s->data[s->top];
s->top=s->top-1;
return
y;
}
main(
){
int
m,n;
printf("请输入要转换的十进制整数:\n");
scanf("%d",&m);
printf("请输入要转换为的进制:\n");
scanf("%d",&n);
SeqStack
*S;
ElemType
x;
InitStack(S);
while(m){
Push(S,m%n);
m
=
m/n;
}
while(!StackEmpty(S)){
x
=
Pop(S);
printf("%d",x);
}
printf("\n");
}
给你个我重新写的
㈣ 关于栈的Top操作的问题 c语言实现 链表实现 数据结构
S不是栈顶，S是栈顶的上面，S->Next指向的才是栈顶，你画个图就知道了，不要把S当做一个节点，S是个指针，不是一个节点，
是个Next指向栈顶的节点指针，S里面的data没用，就那个Next有用
所以S-Next->data是栈顶元素
push是在栈顶上面加的，所以，push实际上是加载了S和旧的栈顶之间，形成了新的栈顶
打印地址
int
类型，%d可以。
㈤ c++关于栈的问题
heap和stack的区别2008-11-26 23:16一、预备知识—程序的内存分配
要点：
堆：顺序随意
栈：先进后出
一个由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\0在常量区，p3在栈上。
static int c =0； 全局（静态）初始化区
p1 = (char *)malloc(10);
p2 = (char *)malloc(20);
分配得来得10和20字节的区域就在堆区。
strcpy(p1, "123456"); 123456\0放在常量区，编译器可能会将它与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 <stdio.h>;
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语言中关于data与stack
内存主要分为代码段，数据段和堆栈。代码段放程序代码，属于只读内存。数据段存放全局变量，静态变量，常量等，堆里存放自己malloc或new出来的变量，其他变量就存放在栈里，堆栈之间空间是有浮动的。数据段的内存会到程序执行完才释放。调用函数先找到函数的入口地址，然后计算给函数的形参和临时变量在栈里分配空间，拷贝实参的副本传给形参，然后进行压栈操作，函数执行完再进行弹栈操作。字符常量一般放在数据段，而且相同的字符常量只会存一份
㈦ msp430编译器的堆栈在哪里设置
我用的是IAR 4.11b for MSP430，4.11里面改堆栈是在你工程的Options里面。首先在Workspace窗口右键单击你的工程，然后选择第一项"Options"，或者选在上面菜单中选择Project->Options也可以进入这个选项。在Options里面第一个General Options中，有一堆选项卡，第五个选项卡(就是Library Options再向右一个)就是Stack/Heap，用来调整堆和栈的大小的。调的时候先在Override Default前面打钩。如果你用的是地址线没有扩展的MCU版本，则只有Stack Size 和Heap Size 两个选项可以选择。如果你是用的是较新的F5系列扩展地址线版本MCU，则还可以设置Data20 Heap Size.具体怎么设要根据你的应用需求。如果你需要自己申请用来存放Data20类型的数据，就需要把Data20 Heap Size设大一点。如果存放普通的数据那么只需要更改Stack Size和Heap Size。
Stack和Heap的区别有问题吗？如果不清楚的话上网络输入“堆和栈的区别”自己看吧。根据你的应用到底是堆空间要求多一些，还是栈空间要求多一些，给Stack Size和Heap Size分配不同大小的Size。
别的版本的IAR我也没用过，有什么问题在线交流吧。希望对你有帮助！
㈧ 关于出栈入栈的问题 class node { int data; node*next; public:…… }；
主要是要明确类的声明和定义的区别
编译器发现 class node 这句话 就已经知道有node这么个类型存在了，那么你在类的
内部声明个node类型的指针就是 正确的了，这个与指针用法没关系，主要是编译器对类的声明和定义如何处理的而已
㈨ C语言代码组成 - BSS、Data、Stack、Heap、Code、Const
一段C语言经过编译连接后，成为一段可以运行的代码，可运行的代码可以分为以下四个部分组成：全局变量/静态变量区、堆、栈、代码区。其中全局变量/静态变量区又分为未初始化变量区和初始化变量区，代码区又分为代码和常量区。即汇总下来，代码可以分为6部分组成，包括：BSS区（未初始化的全局变量/静态变量区）、Data区（实始化的全局变量区）、Stack区（栈区）、heap区（堆区）、Code区（代码区）、const区（常量区）。
一、BSS区和Data区
C语言编程中定义的全局变量、静态局部变量，就是分配在全局变量/静态变量区域，但是为什么又要分为BSS区域和Data区域呢？其实我们在定义全局或者静态变量区，有时我会对它赋初始值，有的又不会赋初始化，比如我们定义的全局变量，初始化的赋值，是怎么样写到变量区域中的，我们定义的静态局部变量，在定义时初始化后，为什么后面函数被调用，又不会再初始化呢？这个局部静态变量是怎么样实始化的，什么时候初始化的？
如果分析编译后的汇编代码，就会发现在代码运行起来后，会有一段给变量赋值的指令，这一段代码，不是我们C代码对应的汇编，而是C编译器生成的汇编译代码，这段代码的作用就是给初始化了的静态变量和全局变量进行初始化。这也是为什么全局/静态变量区域，要分BSS和Data的原因。
二、Stack区
栈是一种先进后出的数据结构，这种数据结构正好完美的匹配函数调用时的模型过程，比如函数f(a)在运行过程中调用函数f(b)，f(a）在运行过程中的变量就是分配在栈中，通过在调用f(b)前，会将代码中用到的R0~Rn寄存器的值保存到栈中，同时将函数的传入参数写入到栈中，然后进入f(b)函数，函数f(b)的变量b分配在栈中，当函数运行完毕后，释放变量b，将栈中存放的f（a）函数的运行的R0~Rn寄存器值恢复到寄存器中，同时f(b)的返回结果存入到栈中，这样f（a）继续运行。当一个函数运行完毕后，它在栈中分配的临时变量会全部释放。
对于中断也是一样的，中断发生时，也是一个函数打断了另一个函数的运行，这种现场的保存（即寄存器的值）,都是通过栈来完成的。所以栈的作用有：
三、Heap区
全局变量分配的内存在代码整个运行周期内都是有效的，而在栈区分配的内存在函数调用完成后，就会释放。这两种内存模型都是由编译器决定它的使用，代码是无法控制的。那有没有内存是由用户控制的，要用时，就自由分配，不用时，就自行释放？答案是肯定的，这部分内存就是堆。
用户需要使用的动态内存，就是通过malloc函数，调用分配的，在没有释放前，可一直由代码使用。当这部分内存不再需要使用时，可以通过free函数进行释放，将它归还到堆中。从这中可以看出，堆的内存，是按需分配的。这就是赋予了代码很大的自由度，但这也是会带来负作用的，比如：内存碎片化导致的malloc失败；忘记释放内存导致的内存泄露，而这些往往是致命的失误。
四、Code区
代码区就是编译后机器指令，这些指令决定了功能的执行。我们编译的代码一般是下载进flash中，但是运行，却有两种方式：在RAM中运行和在ROM中运行。 在RAM中运行，即是boot启动后，将flash中的代码复制到RAM中，然后PC指针在指到RAM中的代码中开始运行。 有时在调试时，我们可以直接将代码下载进RAM中运行进行调试，这样加快调试速度。便是大部分的情况我们的代码是从flash中开始运行的。
五、常量区
代码中的常量，一部分是作为立即数，在代码区中，但是像定义的字符串、给某数组赋值的一串数值，这些常量，就存在常量区，我们常用const来定义一个常量，即该变量不能再必变。这部分的变量，编译器一般将它定义的flash中。
六、各个区域大小的是如何决定的：
code区和const区：是由代码的大小和代码中常量的多少来决定的。
bss区和data区：这是由代码中定义的全局变量和局部变量的多少来决定的。
stack区：这个可以由使用都自行定义大小，但使用都要根据自已代码的情况，评估出一个合理的值，再定义其大小，如果定义的太小，很容易爆栈，导至代码异常，但是如果定义的太大，就容易浪费内存。
heap区：RAM剩下的部分，编译器就会作为堆区使用。
七、嵌入式代码一般启动过程
以STM32为例，通过分析其汇编启支代码，大致可以分为以下几个步骤：
如果大家想看编译扣，代码文件的组成，可以查看统后生的map文件，里面有详细的数据，包括各个函数的分配内存，BSS，Data，Stack，Heap，Text的分配情况。
如果相要了解详细的代码启动过程，可看它的启动汇编文件。
㈩ 数据结构栈实现的代码有些问题，自已看不出，请高手指教
帮你改了一下：
#include
<stdio.h>
#include
<stdlib.h>
#define
StackSize
8
typedef
struct
{
char
data[StackSize];
int
top1,top2;
}DbStack;
void
initStack(DbStack
*s)
{
s->top1
=
-1;
s->top2
=
8;
}
//判断栈满
int
stackFull(DbStack
*s)
{
return
s->top1
==
s->top2-1;
}
//入栈
void
push(DbStack
*s,
char
c,int
k)
{
if
(stackFull(s))
{
printf("overFlow");
return
;
}
switch
(k)
{
case
1:
s->data[++s->top1]
=
c;
break;
case
2:
s->data[--s->top2]
=
c;
//应该是--s->top2才对，要不然数组越界啦
break;
default:
printf("k不合法");
return
;
}
}
//显示
void
dis(DbStack
*s,int
k)
{
if(k
==1)
{
if(s->top1!=-1)
//还有这里
{
while
(s->top1!=-1)
{
printf("%d",s->data[s->top1-1]);
//s->top1不变就可以啦，没必要用count
}
｝
printf("Stack
is
empty");
}
esle
if(k
==
2)
//还有这里
{
if(s->top2
!=
8)
{
while
(s->top2!=8)
{
printf("%c",s->data[s->top2+1]);
//一样的！s->top2不变就可以啦，没必要用count
}
}
printf("Stack
is
empty");
}
}
main()
{
DbStack
*s;
s
=(DbStack*)
malloc(sizeof(DbStack));
initStack(s);
push(s,'f',1);
push(s,'d',1);
push(s,'e',1);
push(s,'g',2);
push(s,'h',2);
push(s,'i',2);
dis(s,1);
dis(s,2);
}
你自己再检查一下吧