Void main( ){ stack s; char x,y; InitStack(s); x=‘c’;y=‘k’; push(s,x); push(s,’a’); push

vt. & vi. 1. 堆积n. 1. 堆, 垛2. 大量, 一大堆3. 大烟囱; (船上的)烟囱4. (图书馆或书店的)书架

stack把…成叠地放在〔某处〕用法：He went back to stacking the shelves.他继续把货物摆上货架。be stacked with sthThe floor was stacked with boxes.地板上堆满了箱子。

n.堆栈；一摞；大量；许多v.（使）放成整齐的一叠（或一摞、一堆）拓展：栈（stack）在计算机科学中是限定仅在表尾进行插入或删除操作的线性表。栈是一种数据结构，它按照后进先出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据。栈是只能在某一端插入和删除的特殊线性表。用桶堆积物品，先堆进来的压在底下，随后一件一件往上堆。取走时，只能从上面一件一件取。读和取都在顶部进行，底部一般是不动的。栈就是一种类似桶堆积物品的数据结构，进行删除和插入的一端称栈顶，另一端称栈底。插入一般称为进栈，删除则称为退栈。 栈也称为后进先出表。

stackKK: []DJ: []n.[C]1. 干草堆,稻草堆,麦秆堆The grain has gone mouldy in the stack.垛里的谷子发霉了。2. (整齐的)一堆,一叠[S][(+of)]He placed his books in a neat stack.他把书整整齐齐放成一堆。3. 【口】大量,许多[P1][(+of)]He"s got stacks of money.他有许多钱。4. (双面)大书架;书库[P1]5. (三支步枪架成的)三角枪架6. 烟囱;一排烟囱;排气管We could see several smoking stacks in the distance.我们可以看到远处好几个冒着烟的烟囱。7. (作定高分层盘旋的)待降机群vt.1. 把...叠成堆[(+up)]Mother is stacking the plates in the kitchen.母亲在厨房里把盘子一个个叠起来。2. 堆放[H][(+with)]The room was stacked with old books and magazines.房间里堆满了旧书和旧杂志。3. 把...支成三角枪架4. 指令(待降飞机)作定高分层盘旋[(+up)]5. 对...作弊[(+against)]The memberships of this committee are stacked to give the majority party substantial control.有人在这个委员会的组成上搞了鬼,以使多数党取得相当多的控制权。vi.1. 形成堆These plates stack well.这些盘子叠得很平整。2. (待降飞机)作定高分层盘旋3. 【美】【口】比较[(+up against)]How does their product stack up against those imported from foreign countries?他们的产品与从外国进口的产品相比如何?

堆积，堆叠。

stack [st03k]n. 堆叠, 堆; 书架; 烟囱; (计算机用语) 可以存储信息然后可以按倒序提取的记忆区; (因特网用语) 用来传送信息的敞开系统内部连接的一层v. 堆积, 做牌, 堆满; 形成堆; 比较; 作定高分层盘旋stackA command which removes a word from the top of the stack.一种从栈顶移走一个字［项］的命令。-- 英汉 - 辞典例句A sufficiently energetic particle can penetrate the entire stack of parallel plates.能量充足的粒子能够穿透全部平行板。-- 英汉 - 辞典例句Each session would produce a big stack of typewritten notes.每一次都能收获一大叠打字笔记。-- 英汉 - 辞典例句He is all abroad as to how things stack up today.他对当前总的形势毫无所知。-- 英汉 - 辞典例句How does their product stack up against the competition of other firms?他们的产品同其他公司的相比怎么样?-- 英汉 - 辞典例句How does their product stack up against those imported from foreign countries?他们的产品与从外国进口的产品相比如何?-- 英汉 - 辞典例句Large stack deposits are controlled by deeply dipping faults Tertiary age.巨大的堆型矿体受第三纪倾陡断层控制。-- 英汉 - 辞典例句That"s how things stack up today.目前的情况总之就是这样。-- 英汉 - 辞典例句These plates stack well.这些盘子叠得很平整。-- 英汉 - 辞典例句There is a stack of dishes to be washed in the kitchen.厨房里还有一大堆盘子要洗。

一、主体不同1、sqstack：指顺序栈，指利用顺序存储结构实现的栈。2、stack：又名堆栈，它是一种运算受限的线性表。二、数据操作不同1、sqstack：用地址连续的存储空间（数组)依次存储栈中数据元素，由于入栈和出栈运算都是在栈顶进行，而栈底位置是固定不变的，可以将栈底位置设置在数组空间的起始处。2、stack：按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据。三、特点不同1、sqstack：利用内存中的一片起始位置确定的连续存储区域来存放栈中的所有元素，另外为了指示栈顶的准确位置，还需要引入一个栈顶指示变量top。2、stack：允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。参考资料来源：百度百科-栈参考资料来源：百度百科-顺序栈

　　stack有堆;一大堆;堆积;堆放等意思，那么你知道stack的用法吗?下面是我为大家整理的stack的用法和相关 短语 例句，欢迎大家学习! 　　stack的用法： 　　stack的用法1：stack的意思是指将某物堆在一起或集中起来。用于抽象事物也可表示“紧密安排在一起”。强调有序与谨慎。 　　stack的用法2：stack可用作不及物动词,也可用作及物动词。用作及物动词时,可接名词或代词作宾语,可用于被动结构。 　　stack的用法3：stack接谷物、草等时,指捆成捆,码成圆锥体形; 接木棒时,指垛成长方体形; 接木材时,指一层层堆起来以便透气、不翘曲; 接枪支时,指堆成棱锥体形。 　　stack的用法4：stack还可用作可数名词,意为“整齐的一叠或一堆”。例如:There are stacks of wood in the house.房子里有一堆堆的木头。 　　stack的常用短语： 　　用作动词 (v.) 　　stack the cards〔chances,odds〕 against (v.+n.+prep.) 　　stack up (v.+adv.) 　　stack的用法例句： 　　1. He ordered them to stack up pillows behind his back. 　　他命令他们把几个枕头叠放在自己的背后。 　　2. They said they were going to stack the court with anti-abortion judges. 　　他们说将会往法院中安排一些反对堕胎的法官。 　　3. A stack of files awaited me on my desk. 　　我桌上有一堆文件正待我去处理。 　　4. I have a stack of emails in my inbox. 　　我的收件箱里有很多电邮。 　　5. a stack of books 　　一摞书 　　6. There"s a whole stack of bills waiting to be paid. 　　有一大堆账要付呢. 　　7. They are specially packaged so that they stack easily. 　　它们经过特别包装以便于堆放. 　　8. How does our product stack up against those of our competitors? 　　我们的产品与我们的竞争者的产品比起来 如何 ? 　　9. How much do all these figures stack up to? 　　这些数字的总和是 多少 ? 　　10. What did our sales stack up to last month? 　　到上个月为止我们的销售额达到了多少? 　　11. When he came in and saw the mess, he blew his stack. 　　当他进来看到一团糟时, 大发雷霆. 　　12. Please stack the materials up here. 　　请把材料堆在这里. 　　13. This is how things stack up today. 　　这就是当今的状况. 　　14. Double-stack trains are taking a lot of freight that used to be routed via trucks. 　　以往由卡车运送的很多货物现在都改用双层列车运送了。 　　15. How does this final presidential debate stack up and compare to the others, do you think? 　　你认为这最后一次总统竞选 辩论 和其他几次相比怎么样?

网上收集的一些资料： 1.栈是存放函数返回、参数、局部变量的。 堆是程序可以操作的内存，使用时先申请，用完之后释放，如何使用完全由程序代码控制。 2.栈在汇编代码中表示成PUSH POP，用的是ESS段，SP寄存器 而堆不是，是在内存中读写，EDS段， 3. C++包括两种被应用程序管理的内存区域:一种称为栈(stack),另一种称为堆(heap)。 stack是函数被调用时自动分配的一块内存区域，它主要用于保留函数内使用的变量及函数调用位置处下一条代码的。 stack是后进先出，一个可变的指针指向stack的顶部。 本质上，当一个函数被程序调用时，当前的执行被放入stack,如果有参数传递到函数内，这些参数也被压入stack,如果函数内有变量，它们也被压入stack,如果函数执行时调用另一个函数，重复上面的过程。 当从函数返回时，stack指针指向存放先前执行的位置，也就是说，stack空间内分配的元素已被删除。这就是为什么函数内的变量此时无效，因为它们已经被推出了stack,另外要注意的是，声明一个静态变量，它没有进入stack中。 另一种由应用程序管理的内存区域是堆(heap),heap是储存应用程序的内存分配需求，并且分离于程序代码和stack,heap中分配的对象的总的空间受限于计算机系统中有效的虚拟内存。 C程序通常使用lloc和free分配和回收heap内存，在C++中，使用new和delete. 4.函数里的变量一般是stack，用new和lloc分配的是heap stack是有大小限制的，heap的大小与系统虚拟内存差不多 stack运算比heap快 stack由编译器来管理，heap由程序员new, lloc, delete, free 5.heap____存储区 stack____局部存储区 通常意义上的堆栈一般指的就是栈电阻有很多种类的想了解更加详细的技术参数的话百度搜硬之城去那里了解下，好过自己在这里瞎琢磨专业的地方解决专业的问题，这个都是很现实的。

Stack和Reach是一个绝对的测量系统，本质上可以是自行车上任何一点，测量这个点到五通的水平和垂直距离。但有价值的分别是：车把Stack和Reach，车架Stack和Reach。车把到墙的水平距离为BARx，车把到地板的垂直距离为BARy头管中心到墙的水平距离为FRAMEx，头管中心到地板的垂直距离为FRAMEy五通中心到墙的水平距离为BBx，五通中心到地板的垂直距离为BBy。车把的Stack和Reach可以通过把立长度和垫圈高度进行调整，是你最终得到的操作空间。车把Reach=BARx-BBx车把Stack=BARy-BBy车架Stack和Reach是你购买新车架主要的参考数据，代表车架的尺寸。

The goods can be stacked 3 layers at most. Pile是“堆”的意思, a collection of objects laid on top of each other （一堆物品一个摞在另一个上面） 而stack是“栈”的意思 an orderly pile (有序的堆放) 由于教科书倾向于把stack翻译成“堆栈”,所以常常使人再遇到pile时感到迷惑不解

stack灯闪烁。答stack灯闪烁。

两个::表示作用域限定符。比如：stack::stack的第一个stack是类名或结构体名；第二个stack是构造函数名（c++规定构造函数要与类或结构体同名）；而::指定第二个stack是第一个类（或结构体）stack的构造函数，而不是其它类或结构体的构造函数。像这种语法主要用在在类或结构体的里面声明其成员，而在外面定义其成员的时候。比如：class student{public://构造函数的声明（在类内）student(string id,string name,int age);//下面两个是设置、获取学号函数的声明void setid(string id);string getid();//其它函数的声明（如有）//......//成员变量的声明private:int age;string id,name;};//构造函数的定义（在类外）student::student(string id,string name,int age){this->id=id;this->name=name;this->age=age;}//设置学号函数的定义（在类外）void student::setid(string id){this->id=id;}//获取学号函数的定义（在类外）string student::getid(){return id;}//其它函数的定义（在类外）//......

可以用链表形式实现，每个节点是一个结构体。栈的深度就是节点个数。组数可控制循环次数。

//遍历先序二叉树（非递归）//访问T->data后，将T入栈，遍历左子树；//遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。void preorder_stack(Bitnode *t){ Bitnode *stack[MAXN]; int top = -1; while(t || top!=-1) { while(t) { printf("%c",t->data); stack[++top] = t; t = t->lchild; } if(top != -1) { t = stack[top--]; t = t->rchild; } }}//遍历中序二叉树（非递归）//先将T入栈，遍历左子树；//遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。void inorder_stack(Bitnode *t){ Bitnode *stack[MAXN]; int top = -1; while(t || top!=-1) { while(t) { stack[++top] = t; t = t->lchild; } if(top != -1) { t = stack[top--]; printf("%c",t->data); t = t->rchild; } }}//遍历后序二叉树（非递归）//可采用标记法，结点入栈时，配一个标志tag一同入栈(0：遍历左子树前的现场保护，1：遍历右子树前的现场保护)。//首先将T和tag(为0)入栈，遍历左子树；返回后，修改栈顶tag为1，遍历右子树；最后访问根结点。 void postorder_stack(Bitnode *t){ Bitnode *stack[MAXN]; bool tag[MAXN]; int top = -1; while(t || top!=-1) { while(t) { stack[++top] = t; tag[top] = 0; t = t->lchild; } while(top!=-1 && tag[top] == 1) { t = stack[top--]; printf("%c",t->data); } if(top != -1) { tag[top] = 1;// 设置栈顶标记 t = stack[top];// 取栈顶保存的指针 t = t->rchild; } else break; }}

stack[stAk]n.堆, 一堆, 堆栈v.堆叠你可以理解为我们通常叫的焊盘.

此语句的含义是定义一个char数据类型的栈s

你到www.csdn.net上去问，那里是专门的程序员论坛

堆和栈的区别：　　一、堆栈空间分配区别：　　1、栈（操作系统）：由操作系统自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈；　　2、堆（操作系统）：一般由程序员分配释放，若程序员不释放，程序结束时可能由os回收，分配方式倒是类似于链表。　　二、堆栈缓存方式区别：　　1、栈使用的是一级缓存，通常都是被调用时处于存储空间中，调用完毕立即释放；　　2、堆是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。　　三、堆栈数据结构区别：　　堆（数据结构）：堆可以被看成是一棵树，如：堆排序；　　栈（数据结构）：一种先进后出的数据结构。

一维数组stack(1,n)是一个下标从1到n的数组。中括号中写明元素个数，如果没写明，后面必须跟随初始化参数，然后让编译程序帮你算元素个数引用时，中括号中写明元素下标值，取值从0开始到数组元素个数减1为止。main( ){int x[10]; /* 定义包含1 0个整型数的数组，引用为x [ 0 ] ，x [ 1 ] . . . x [ 9 ] * /int t ;for (t=0; t<10;++t) x[t]=t;}。元素的表示方法：二维数组的元素也称为双下标变量，其表示的形式为：数组名[下标][下标]，其中下标应为整型常量或整型表达式。例如：a[3][4] 表示a数组三行四列的元素。下标变量和数组说明在形式中有些相似，但这两者具有完全不同的含义。数组说明的方括号中给出的是某一维的长度，即可取下标的最大值； 而数组元素中的下标是该元素在数组中的位置标识。前者只能是常量， 后者可以是常量，变量或表达式。

一、基本概念　　栈（stack）在计算机科学中是限定仅在表尾进行插入或删除操作的线形表。　　栈是一种数据结构，是只能在某一端插入和删除的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。　　栈是允许在同一端进行插入和删除操作的特殊线性表。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个数为零时称为空栈。插入一般称为进栈（PUSH），删除则称为退栈（POP）。 栈也称为后进先出表（LIFO表）。　　栈可以用来在函数调用的时候存储断点，做递归时要用到栈！　　 栈的模型二、基本算法　　　　1、进栈（PUSH）算法　　①若TOP≥ｎ时，则给出溢出信息，作出错处理（进栈前首先检查栈是否已满，满则溢出；不满则作②）；　　②置TOP=TOP+1（栈指针加１，指向进栈地址）；　　③S(TOP)=X，结束（X为新进栈的元素）；　　2、退栈（POP）算法　　①若TOP≤0，则给出下溢信息，作出错处理(退栈前先检查是否已为空栈， 空则下溢；不空则作②)；　　②X=S(TOP)，（退栈后的元素赋给X）；　　③TOP=TOP-1，结束（栈指针减１，指向栈顶）。　　 三、栈的实现　　在pascal下的实现　　1、数组型　　Const 　　m=栈表目数的上限; 　　Type 　　stack=array[1..m] of stype; {栈类型} 　　Var 　　s:stack;{栈} 　　top:integer; {栈顶指针}　　2、记录型　　const 　　m=栈表目数的上限； 　　type 　　stack=record 　　elem: array[1..m] of elemtp; 　　top:0..m; {栈顶指针} 　　end;　　Var 　　s:stack;{栈} 　　在C/C++中栈的一些基本操作:　　C代码:　　/*　　@**2009/09/24　　栈的基本操作　　*/　　#include <iostream>　　#define MaxSize 100　　using namespace std;　　typedef struct　　{　　int data[MaxSize];　　int top;　　}SqStack;　　void InitStack(SqStack *st) //初始化栈　　{　　st->top=-1;　　}　　int StackEmpty(SqStack *st) //判断栈为空　　{　　return (st->top==-1);　　}　　void Push(SqStack *st,int x) //元素进栈　　{　　if(st->top==MaxSize-1)　　printf("栈上溢出! ");　　else　　{　　st->top++;　　st->data[st->top]=x;　　}　　}　　void Pop(SqStack *st) //退栈　　{　　if(st->top==-1)　　printf("栈下溢出 ");　　else　　st->top--;　　}　　int Gettop(SqStack *st) //获得栈顶元素　　{　　if(st->top==-1)　　{　　printf("栈空 ");　　return 0;　　}　　else　　return st->data[st->top];　　}　　void Display(SqStack *st) //打印栈里元素　　{　　int i;　　printf("栈中元素：");　　for(i=st->top;i>=0;--i)　　printf("%d ",st->data[i]);　　printf(" ");　　}　　int main()　　{　　SqStack L;　　SqStack *st=&L;　　InitStack(st);　　printf("栈空：%d ",StackEmpty(st));　　for(int i=1;i<10;++i)　　Push(st,i);　　Display(st);　　printf("退一次栈 ");　　Pop(st);　　printf("栈顶元素:%d ",Gettop(st));　　Pop(st);　　Display(st);　　return 0;　　}

strcmp这个函数原形是 int strcmp(char *,char*)，你传入一个string的对象进去是不行的。

首先，要分清楚两个东西：一个是stack，它表示栈。一个是BiTree，它表示栈内存放的数据类型，这是一个自定义类型。所以，整体这句话的意思是：声明一个栈变量s，它所存放的类型是BiTree。

"&"的意思是取地址符，代表引用。如果你要对栈进行查找、求长度等不改变栈的操作，就不用加&，如果你要进行的操作进行之后改变了原来的栈，如删除、插入等操作，就要加&。

stack堆栈n. 堆；堆叠vt. 使堆叠；把…堆积起来vi. 堆积，堆叠

顺序存储结构简称为顺序栈。和顺序表类似，对顺序栈也需要事先为它分配一个可以容纳最多元素的存储空间。链栈即为栈的链式存储结构。顺序栈：栈以顺序存储的结构，利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素。 code：typedef int DataType;//自定义的数据类型class Stack_Array //顺序栈{private:int top;int max_size;DataType *vec; //指向自定义数据类型的指针public:Stack_Array(int size){vec = new DataType[size];top = -1;max_size = size;}~Stack_Array(){delete [] vec; //此处记得加上[]，因为是数组}void push(DataType x){if (top==(max_size-1)){cout<<"up overflow!";}vec[++top] = x;}DataType pop(){if (top==-1){cout<<"under overflow";}return vec[top--];}};链栈：栈的链式存储结构，利用一个线性链表来存储栈中的数据元素。code：typedef int DataType;typedef struct ListNode{ListNode *next;DataType data;}ListNode_t;class Stack_list//链栈{private:ListNode_t *top;//指向链结点的指针public:Stack_list(){top = NULL;}~Stack_list();void push(DataType x){ListNode_t *temp = new ListNode_t;temp->next = top;temp->data = x;top = temp;}DataType pop(){DataType x;ListNode_t *temp;if (top != NULL){temp = top;top = top->next;x = temp->data;delete temp;//此处记得释放return x;}return NULL;}};

实际高度。stack在图纸中代表实际高度，Stack是五通到头管顶部之间的垂直距离。例如，耐力型的公路车通常会比气动型的公路车具有更大的stack值。stack数值越大，则车座越高。

栈

堆栈是一种机制，计算机用它来将参量传递给函数，也可以用于指向局部函数变量。它的目的是赋予程序一个方便的途径来访问特定函数的局部数据，并从函数调用者那边传递信息。堆栈的作用如同一个缓冲区，保存着函数所需要的所有信息。在函数开始的时候产生堆栈，并在结束的时候释放它。堆栈一般是静态的，也即意味着一旦在函数的开始创建一个堆栈，那么堆栈就是不可以改变的。堆栈所保存的数据是可以改变的，但是堆栈的本身一般是不可以改变的。

堆(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个元素有最高的优先权；栈实际上就是满足先进后出的性质的数学或数据结构。 虽然堆栈，堆栈的说法是连起来叫，但是他们还是有很大区别的，连着叫只是由于历史的原因针值读.以上解释是从百度知道问答上转过来的，这两个概念模糊了很久，现在明白了为什么当时计算机专业开“数据结构”了，呵呵，有时间还要补补！

Stack和Reach是一个绝对的测量系统，本质上可以是自行车上任何一点，测量这个点到五通的水平和垂直距离。但有价值的分别是：车把Stack和Reach，车架Stack和Reach。车把到墙的水平距离为BARx，车把到地板的垂直距离为BARy头管中心到墙的水平距离为FRAMEx，头管中心到地板的垂直距离为FRAMEy五通中心到墙的水平距离为BBx，五通中心到地板的垂直距离为BBy。车把的Stack和Reach可以通过把立长度和垫圈高度进行调整，是你最终得到的操作空间。车把Reach=BARx-BBx车把Stack=BARy-BBy车架Stack和Reach是你购买新车架主要的参考数据，代表车架的尺寸。

The goods can be stacked 3 layers at most. Pile是“堆”的意思, a collection of objects laid on top of each other （一堆物品一个摞在另一个上面） 而stack是“栈”的意思 an orderly pile (有序的堆放) 由于教科书倾向于把stack翻译成“堆栈”,所以常常使人再遇到pile时感到迷惑不解

消费者的购买决策。马歇尔stack模式指的是消费者的购买决策，而决策要基于理性判断和清醒的经济计算。马歇尔模式源于亚当斯密的“自我利益”动机、边沁的消费行为“精于计算”的观点以及瓦格纳斯等人的“边际效用”理论。

重载“-”为出栈？“<<”?判栈有判空和判满。#include<iostream>using namespace std;template <class T>class Stack{ private: int size; int top; T *space; public: Stack(int n); ~Stack() { delete [] space; } void push( T t); friend ostream& operator<<(ostream& out,Stack &st) { while(!(st.operator()())) out<< st.space[st.top++]<<endl; return out; }bool operator ()() const { return top == size; } bool Isfull() const { return top == 0; }};template <class T>Stack<T>::Stack(int size){ this->size = size; top = size; space = new T [size];}template <class T>void Stack<T>::push(T t){ if(!Isfull()) space[--top] = t;}int main(){ Stack<int>s(20);//可以指定栈的大小 s.push(1); s.push(2); s.push(3); s.push(4); s.push(5); s.push(6); cout<<s;}这个没问题，如果是重载 - 改为：#include<iostream>using namespace std;template <class T>class Stack{ private: int size; int top; T *space; public: Stack(int n); ~Stack() { delete [] space; } void push( T t); friend Stack & operator -(Stack &st) { while(!(st.operator()())) cout<< st.space[st.top++]<<endl; }bool operator ()() const { return top == size; } bool Isfull() const { return top == 0; }};template <class T>Stack<T>::Stack(int size){ this->size = size; top = size; space = new T [size];}template <class T>void Stack<T>::push(T t){ if(!Isfull()) space[--top] = t;}int main(){ Stack<int>s(20);//可以指定栈的大小 s.push(1); s.push(2); s.push(3); s.push(4); s.push(5); s.push(6); -s;}但是这个在VC下不行，在codeblocks下使用mingw32-g++.exe可以正常编译执行，运行截图： 请参考

你打错了吧！是不是static?静态的意思

你是对的。

s是一个SeqStackCar类型的指针，你看一下SeqStackCar这个结构，里面有top成员和CarNode *stack[Max+1]， 所以现在top成员初始化为0，所以s->stack[s->top]就是s->stack[0]，很显然他表示的是一个指针类型，初始化让他指向NULL不过我觉得这个初始化有点问题，循环体内不断将s->stack[s->top]指向NULL，没意义啊，估计应该是s->stack[i]

栈是一种线性表，它的特点是什么？ 栈（stack）在电脑科学中是限定仅在表尾进行插入或删除操作的线形表。 栈是一种资料结构，它按照先进后出的原则储存资料，先进入的资料被压入栈底，最后的资料在栈顶，需要读资料的时候从栈顶开始弹出资料（最后一个数据被第一个读出来）。 栈是只能在某一端插入和删除的特殊线性表。用桶堆积物品，先堆进来的压在底下，随后一件一件往堆。取走时，只能从上面一件一件取。堆和取都在顶部进行，底部一般是不动的。 栈就是一种类似桶堆积物品的资料结构，进行删除和插入的一端称栈顶，另一堆称栈底。插入一般称为进栈（PUSH），删除则称为退栈（POP）。 栈也称为后进先出表（LIFO表）。1、进栈（PUSH）演算法 ①若TOP≥n时，则给出溢位资讯，作出错处理（进栈前首先检查栈是否已满，满则溢位；不满则作②）； ②置TOP=TOP+1（栈指标加1，指向进栈地址）； ③S(TOP)=X，结束（X为新进栈的元素）； 2、退栈（POP）演算法 ①若TOP≤0，则给出下溢资讯，作出错处理(退栈前先检查是否已为空栈， 空则下溢；不空则作②)； ②X=S(SOP)，（退栈后的元素赋给X）； ③TOP=TOP-1，结束（栈指标减1，指向栈顶）。 栈和伫列都是特殊线性表，简述他们的区别（特殊性） 栈是先进后出，队是先进先出，这是他们存取上的根本不同 栈和线性表有什么区别？ 一般线性表使用阵列来表示的 线性表一般有插入、删除、读取等对于任意元素的操作 而栈只是一种特殊的线性表 栈只能在线性表的一端插入（称为入栈,push）或者读取栈顶元素或者称为“弹出、出栈”(pop)。 栈在阵列的基础上可以用一个指向栈顶的标骇符来表示，如a表示栈，则a[top]就表示栈顶元素 栈就是所谓的“先进后出,First in last out, FILO” 堆叠是一种结构较简单的线性表，它只允许在表的一端进行资料的插入和删除操作 20分 stack.h: header file class Stack { int MaxStack; int EmptyStack; int top; char* items; public: Stack(int); ~Stack(); void push(char); char pop(); int empty(); int full(); }; ------------------------------- stack.cpp: stack functions #include "stack.h" Stack::Stack(int size) { MaxStack = size; EmptyStack = -1; top = EmptyStack; items = new char[MaxStack]; } Stack::~Stack() {delete[] items;} void Stack::push(char c) { items[++top] = c; } char Stack::pop() { return items[top--]; } int Stack::full() { return top + 1 == MaxStack; } int Stack::empty() { return top == EmptyStack; } ------------------------------- stackmain.cpp: use stack #include #include "stack.h" int main() { Stack s(10); 10 chars char ch; while ((ch = cin.get()) != " ") if (!s.full()) s.push(ch); while (!s.empty()) cout << s.pop(); cout << endl; return 0; } 串是一种特殊的线性表，其特殊性体现在什么地方 串是一种特殊的线性表,其特殊性体现在资料元素是一个字元 串值也可用连结串列来储存,由于串的资料元素是一个字元,它只有8位二进位制数, 因此用连结串列储存时,通常一个结点中存放的不是一个字元,而是一个子串,例如: 在编辑系统中,整个文字编辑区可以看成是一个串,每一行是一个子串,构成一个结点。 栈和线性表有什么区别 一般线性表使用阵列来表示的 线性表一般有插入、删除、读取等对于任意元素的操作 而栈只是一种特殊的线性表 栈只能在线性表的一端插入（称为入栈,push）或者读取栈顶元素或者称为“弹出、出栈”(pop)。 栈在阵列的基础上可以用一个指向栈顶的识别符号来表示，如a表示栈，则a[top]就表示栈顶元素 栈就是所谓的“先进后出,First in last out, FILO” ( )是一种先进先出的线性表。 A 栈 B伫列 C杂凑表（散列表） D二叉树 B 伫列 栈的概念是弹压，就像子弹壳装弹，一粒一粒压进去，但是打出来的时候是从上面打骇来的，最先压进去的最后弹出来，如果进去顺序是123，打出来顺序是321，这就是后进先出 伫列的概念就是我们平时排队，按次序来，你排在第1个，那你就第一个轮到，就是先进先出，先到先来 栈是插入和删除只能固定在一端进行的线性表，也称“后进先出表”。 有2个问题需要澄清： 1.栈是一种后进先出的资料结构，只能在末端进行插入和删除的操作。应该说成是只能线上性表的一端进行插入和删除。说成末端，就认为的把线性表分成开始端和结束端了。但由于线性表中元素只具有线性关系，并没有明确的起始元素和终止元素。 2.函式呼叫之所以需要栈，是因为函式执行过程中，还能会巢状呼叫其他函式，但无论巢状呼叫多少个函式，总是要遵循一个原则：后被呼叫的函式要先执行完毕，程式要回到上一层函式的呼叫处继续执行，为了实现这个机制，才设计了栈这种后进先出的资料结构。如果把函式呼叫看成罗餐盘的话，而把当你去盘子的时候，肯定先取走最后一个罗上去的盘子，那么函式执行结束，函式呼叫返回就相当于你在取盘子。

在程序没有定义堆栈段的情况下，在由连接程序生成执行文件时，将会产生一条warning no stack segment的警告信息， 当然你不必理会它，所生成的执行文件是可以正常运行的。这是因为：如果在程序中不定义堆栈段，那么，操作系统在装入该执行程序时将自动为其指定一个64K字节的堆栈段，所以你没申明堆栈当然也可以用PUSH/POP。操作系统在把应用程序装入内存时，默认分配堆栈段与代码段同段，应用程序可以自行设置自己的堆栈段。自行设置的堆栈段大小最小4个字节（只够PUSH/POP CS、IP），用于从应用程序返回操作系统。只有较大的程序或递归调用较深的程序，才有必要设置独立 的堆栈段；在程序中可以定义它，也可以不定义。一个完整的源程序（尤其是PUSH/POP 操作特别多，比如有递归的时候）一般最好定义堆栈段。HITWH LEVI

1、连接对象不同TRUNK模式：可以允许多个VLAN通过，可以接收和发送多个VLAN 报文，一般用于交换机与交换机相关的接口。ACCESS模式：可以允许多个VLAN通过，可以接收和发送多个VLAN 报文，可以用于交换机的间连接也可以用于连接用户计算机。2、发送数据处理方法不同ACCESS模式和TRUNK模式在接收数据时，处理方法是一样的，但发送数据时：ACCESS模式可以允许多个vlan的报文不打标签，而TRUNK模式只允许缺省vlan的报文不打标签，同一个交换机上不能hybrid和trunk并存。3、作用不同TRUNK模式主要用在交换机之间互连，使交换机上不同VLAN共享线路。ACCESS模式：主要实现高隔离度的波分和复用。

sped指示符是网络速率指示符，表示交换机中的网络数据传输。stck指示符是堆栈指示符，这意味着有多个开关一起工作。 Sped指示灯闪烁越快，交换机内的数据交换越频繁，数据请求指令越多。指示灯闪烁越慢，内部数据交换量越低

这里我使用标准库里边的vector来对stack进行实现：入栈：即pust()，对应于vector里边的push_back()；出栈：即pop(),对应于vector里边的pop_back()；(标准库中的stack的成员函数pop()没有返回值，也就是说，不“把最后放入栈的object拿出来”，只移除最上面的元素------你上面的意思就是返回最上面的值，使用top()就行了）得到顶部元素：即top(),对应于vector里边的back();判断是否为空：即empty(),对应于vector里边的empty(),最大容量：vector里边有max_size()就返回的是最大容量，所以没有必要再设定一个属性来标记最大容量：// stack.h#include <iostream>#include <vector>template <typename Type>class stack {public: stack() : ele(vector<Type>()) { } void push(const Type& item) { if (size() < maxSize) ele.push_back(item); else std::cerr << "full, no more element can be pushed~" << " the max_size of this stack is " << maxSize << " : element " << item << " haven"t be pushed in stack" << std::endl; } Type pop() { Type temp(ele.back()); ele.pop_back(); return temp; } Type& top() { return ele.back(); } const Type& top() const { return ele.back(); } bool empty() const { return ele.empty(); } void set_max(size_t max) { maxSize = max; } size_t size() const { return ele.size(); } size_t max_size() const { erturn maxSize; } bool full() const { if (ele.size() == maxSize) return true; return false; }private: std::vector<Type> ele; size_t maxSize;};// main.cpp#include <iostream>#include "stack.h"using namespace std;int main(){ stack<int> x; x.push(4); cout << x.pop() << endl; x.set_max(5); for (int i = 0; i < 5; ++i) x.push(i); x.push(3); x.set_max(6); x.push(3); cout << x.top() << endl; if (x.full()) cout << "full" << endl; if (x.empty()) cout << "yes" << endl;}本来在stack::push()中不应该使用输出语句，最好使用异常如std::out_of_range最好，我写输出语句，只是为了更好的说明在栈满了之后就不能放入元素了，---我建议应该保持C++标准中stack的用法，没有full()，使用max_size()返回最大容量，你要判断栈是否满了（在程序外边用size()<max_size()即没满，否则就满了（或者溢出)~好了不说了，你看看程序吧，我睡觉了~晚安~

　　“Stack extends Vector”从语义上意味着：堆栈是个向量 或者 堆栈属于向量。　　其实从现实生活中，并不会认为堆栈是从向量衍伸而来的，所以这种继承关系会让人从语义上觉得奇怪。　　有点像是：某人为了贪图方便，定义猴子的时候，直接从人类继承过来了；结果语义变成了 猴子属于人类。　　Effective java上说继承有自己的一些原则，但是显然栈并不是向量，所以栈不应该扩展向量。同样的，Properties不应该继承HashTable.这样回导致子类拥有一些父类的方法，逻辑奇怪也可能出现歧义。

1.栈是存放函数返回地址、参数、局部变量的。堆是程序可以自由操作的内存，使用时先申请，用完之后释放，如何使用完全由程序代码控制。2.栈在汇编代码中表示成PUSH POP，用的是ESS段，SP寄存器而堆不是，是在内存中读写，EDS段，3.C++包括两种被应用程序管理的内存区域:一种称为栈(stack),另一种称为堆(heap)。stack是函数被调用时自动分配的一块内存区域，它主要用于保留函数内使用的变量及函数调用位置处下一条代码的地址。stack是后进先出，一个可变的指针指向stack的顶部。本质上，当一个函数被程序调用时，当前的执行地址被放入stack,如果有参数传递到函数内，这些参数也被压入stack,如果函数内有变量，它们也被压入stack,如果函数执行时调用另一个函数，重复上面的过程。当从函数返回时，stack指针指向存放先前执行地址的位置，也就是说，stack空间内分配的元素已被删除。这就是为什么函数内的变量此时无效，因为它们已经被推出了stack,另外要注意的是，声明一个静态变量，它没有进入stack中。另一种由应用程序管理的内存区域是堆(heap),heap是储存应用程序的内存分配需求，并且分离于程序代码和stack,heap中分配的对象的总的空间受限于计算机系统中有效的虚拟内存。C程序通常使用malloc和free分配和回收heap内存，在C++中，使用new和delete.4.函数里的变量一般是stack，用new和malloc分配的是heapstack是有大小限制的，heap的大小与系统虚拟内存差不多stack运算比heap快stack由编译器来管理，heap由程序员new, malloc, delete, free5.heap____自由存储区stack____局部存储区通常意义上的堆栈一般指的就是栈

楼主真懒啊

使用java。1、打开java设置java-Xmx512m-Xmx512m，stack设置堆最大值，-Xms设置堆初始值。2、调用java-Xmx5g-Xms5gHeapStackDemo1即可。以上就是在程序开发过程中设置stack段的尺寸大小的方法。

好像很多变量和函数的定义不完整吧，应该是片段吧，感觉很简单的，我需要回答什么呀？

模板类了，去看一下模板的知识，stl的东西

#include <stdio.h>#include <stdlib.h>#include <string.h>typedef int DataType;typedef struct node{ DataType data; struct node * next;}Stack;Stack* CreateStack(); //创建栈void StackEmpty(Stack* ); //清空栈void DestoryStack(Stack*); //撤销(删除)栈int IsEmpty(Stack*); //判空int PushStack(Stack*, DataType); //入栈int PopStack(Stack*); //出栈DataType GetTopElement(Stack*); //取栈顶元素Stack* CreateStack(){ Stack *stack = (Stack*)malloc(sizeof(Stack)); if(NULL != stack) { stack->next = NULL; return stack; } printf("out of place. "); return NULL;}//清空栈void StackEmpty(Stack* stack){ while(!IsEmpty(stack)) { PopStack(stack); } printf("now stack is empty. ");}//撤销栈void DestoryStack(Stack* stack){ free(stack); exit(0);}int IsEmpty(Stack* stack){ return (stack->next == 0);}//入栈，成功返回1，失败返回0， 把元素 data 存入 栈 stack 中int PushStack(Stack* stack, DataType data){ Stack* newst = (Stack*)malloc(sizeof(Stack)); if(NULL != newst) { newst->data = data; newst->next = stack->next; //s->next = NULL; stack->next = newst; return 1; } printf("out of place PushStack. "); return 0;}/* 出栈，成功返回1，失败返回0，出栈不取出元素值，只是删除栈顶元素。 如出栈要实现，取出元素值，并释放空间，可结合取栈顶元素函数做修改，这里不再给出。 */int PopStack(Stack* stack){ Stack* tmpst; if(!IsEmpty(stack)) { tmpst = stack->next; stack->next = tmpst->next; free(tmpst); return 1; } return 0;}//取栈顶元素，仅取出栈顶元素的值，取出之后，该元素，任然存在栈中。成功返回元素值，失败输出提示信息，并返回 -1DataType GetTopElement(Stack* stack){ if(!IsEmpty(stack)) { return stack->next->data; } printf("stack is empty GetTopElement. "); return -1;}int main(){ Stack* stack = CreateStack(); char str[200]; printf("请输入字符串："); scanf("%s", str); int num = 0; for (int i = 0; i < strlen(str); i++) { if (!IsEmpty(stack) && GetTopElement(stack) == "(" && str[i] == ")") { PopStack(stack); num++; } else { PushStack(stack, str[i]); } } if (!IsEmpty(stack)) { num = -1; } printf("匹配结果：%d", num); DestoryStack(stack); return 1;}

他是一个伪指令用来定义一个堆栈段