当前位置：首页 » 网站代码 » 堆栈代码

堆栈代码

发布时间: 2021-03-25 12:19:21

A. STACKS SEGMENT ;此处输入堆栈段代码 STACKS ENDS CODES SEGMENT ASSUME CS:CODES,DS:DATAS,SS:STACKS

DATAS SEGMENT
;此处输入数据段代码
DATAS ENDS
STACKS SEGMENT
;此处输入堆栈段代码
STACKS ENDS
CODES SEGMENT
ASSUME CS:CODES,DS:DATAS,SS:STACKS
START:
MOV AX,DATAS
MOV DS,AX
MOV WORD PTR ds:[0100H], 5564H
MOV WORD PTR ds:[0102H], 0C279H
MOV AX, ds:[0100H]
PUSH AX
ADD AL, ds:[0102H];说明标志位是如何确定的
ADC AH, ds:[0103H];说明指令执行原理，包括标志位
MOV ds:[0104H], AX
POP AX
SUB AL,ds: [0102H] ;说明标志位是如何确定的
SBB AH, ds:[0103H];说明指令执行原理，包括标志位
MOV ds:[0106H], AX
MOV AH,4CH
INT 21H
CODES ENDS
END START
说明：我把你的代码全部复制，然后在debug里面编译，首先错误是那些分号不对。把分号改过来，之后是存储器直接寻址错误，直接寻址的问题参考下面：

B. 存储器中有若干数据类型：指令代码，运算数据，堆栈数据，字符代码和BCD码，计算机是如何识别这些代码的

数据和指令抄都以二进制代码的形式存储在存储器。从代码本身无法区别它是数据还是指令，CPU在取指令时把从存储器中读取的信息都看作指令，在读取数据时从存储器中读取的信息都看成是数据。为了区分运算的数据和程序中的指令，程序员在编写程序时需要知道每个数据的存储位置以及指令的存储位置，以避免指令当作数据，或者将数据当然指令。

C. 汇编中，每个题都要定义数据，堆栈，代码段吗

汇编中，一个程序由数据段、堆栈段、代码段和附加段构成，其中附加段可有可无，而前三个段一般都要有。

D. 用C#编写一个堆栈的代码

写一个结构~
要分配空间
STACK需要有顶指针当前指针
POP PUSH
大概这些吧

E. 求用C（TC）程序编写堆栈的基本操作函数的源代码

用来进行数制转换的。。
#include<stdio.h>
#include<malloc.h>
#include<windows.h> //清屏
#define NULL 0

int i_B=2,i_O=8,i_D=10,i_H=16; //全局常量

typedef struct Number
{int num;
struct Number *next;
}Num;

void Push(int iNum,int i); //转换数字，进栈，iNum为待转换的数，i代表进制
void Pop(struct Number *top,int i); //显示结果，出栈，top为栈顶指针，i代表进制
void Conver(int i); //二进制与八进制调用此函数
void Conver_D(int i); //十进制调用此函数
void Conver_H(int i); //十六进制调用此函数
int TestStr(char *cNumber,int i); //检测数据是否合法

void main()
{ char choose,cGo,cExit;
while(1)
{
system("cls");
printf("************************ 数制转换器 ************************\n\n");
printf(" 二进制(B)\t八进制(O)\t十进制(D)\t十六进制(H)\n\n");
printf("请选择待转换的数字类型<Enter>: ");
scanf("%s",&choose);
switch(choose)
{ case 'B':
case 'b':
Conver(i_B); //二进制
break;
case 'O':
case 'o':
Conver(i_O); //八进制
break;
case 'D':
case 'd':
Conver_D(i_D); //十进制
break;
case 'H':
case 'h':
Conver_H(i_H); //十六进制
break;
default:
printf("\n选择时出错!请输入指定的字符,不区分大小写~\n\n");
}//switch
printf("继续转换吗(y/n)? ");
scanf("%s",&cGo);
if(cGo=='y'||cGo=='Y') continue;
else {printf("确定退出(y/n)? ");
scanf("%s",&cExit);
if(cExit=='y'|| cExit=='Y')
{printf("\n按任意键结束...\n");
getchar();
break;}
else continue;}
}//while
}

void Push(int iNum,int i) //进栈
{struct Number *top=NULL,*NewP;
while(iNum!=0)
{
NewP=(struct Number *)malloc(sizeof(struct Number));
if(top==NULL)
{NewP->next=NULL;
top=NewP;
top->num=iNum%i;}
else
{NewP->next=top;
top=NewP;
top->num=iNum%i;
}
iNum=iNum/i;
}//while
Pop(top,i);
printf("\n");
}

void Pop(struct Number *top,int i) //出栈
{ if(top==NULL)
printf("栈空!\n");
else
{ char cell[]="0123456789ABCDEF";
struct Number *temp,*q;
switch(i)
{ case 8: //输出八进制
case 16: //输出十六进制
temp=top;
while(temp!=NULL)
{printf("%c",cell[temp->num]);
q=temp;temp=temp->next;free(q);}
break;
case 2: //输出二进制
int counter=0; //counter用于输出四个数后加空格
temp=top;
while(temp!=NULL)
{++counter;
printf("%c",cell[temp->num]);
q=temp;temp=temp->next;free(q);
if(counter%4==0) printf(" ");}
break;
}//switch
}//else
}

void Conver(int i) //二进制与八进制,原理:先转换成十进制数,再转换成其它进制
{ char *p,Bit[21];
int Result=0,iRec;
p=Bit;
printf("\n请输入一个%d进制数<Enter>: ",i);
while(1)
{scanf("%s",Bit);
iRec=TestStr(p,i); //检测数据的合法性
if(iRec==0) break;
else printf("请重新输入<Enter>: ");
}
while((*p)!='\0') //转换成十进制
{ Result=Result*i+(*p)-'0';
p++;}
printf("\n********************** 转换后结果为: ***********************\n");
if(i==2)
{printf("\n\t\t八进制:");
Push(Result,i_O);}
else
{printf("\n\t\t二进制:");
Push(Result,i_B);}
printf("\n\t\t十进制:%d\n",Result);
printf("\n\t 十六进制:");
Push(Result,i_H);
printf("\n************************ 转换完毕! *************************\n");
}

void Conver_D(int i) //十进制
{ char *p,Bit[21];
int RetD=0,iRec_D;
p=Bit;
printf("\n请输入一个%d进制数<Enter>: ",i);
while(1)
{scanf("%s",Bit);
iRec_D=TestStr(p,i); //检测数据的合法性
if(iRec_D==0) break;
else printf("请重新输入<Enter>: ");
}
while((*p)!='\0')
{ RetD=RetD*i+(*p)-'0';
p++;}
printf("\n********************** 转换后结果为: ***********************\n");
printf("\n\t\t二进制:");
Push(RetD,i_B);
printf("\n\t\t八进制:");
Push(RetD,i_O);
printf("\n\t 十六进制:");
Push(RetD,i_H);
printf("\n************************ 转换完毕! *************************\n");
}

void Conver_H(int i) //十六进制,先转换成十进制,再转换成其它进制
{ char *p,Bit[21];
int RetH=0,iRec_H;
p=Bit;
printf("\n请输入一个十六进制数<Enter>: ");
while(1)
{scanf("%s",Bit);
iRec_H=TestStr(p,i); //检测数据的合法性
if(iRec_H==0) break;
else printf("请重新输入<Enter>: ");
}
while((*p)!='\0') //十六进制转换成十进制
{
switch(*p)
{case 'A':
case 'a':RetH=RetH*16+10;break;
case 'B':
case 'b':RetH=RetH*16+11;break;
case 'C':
case 'c':RetH=RetH*16+12;break;
case 'D':
case 'd':RetH=RetH*16+13;break;
case 'E':
case 'e':RetH=RetH*16+14;break;
case 'F':
case 'f':RetH=RetH*16+15;break;
default:RetH=RetH*16+(*p)-'0';}
p++;
}
printf("\n********************** 转换后结果为: ***********************\n");
printf("\n\t\t二进制:");
Push(RetH,i_B);
printf("\n\t\t八进制:");
Push(RetH,i_O);
printf("\n\t\t十进制:%d\n",RetH);
printf("\n************************ 转换完毕! *************************\n");
}

int TestStr(char *cNumber,int i) //检测数据是否合法
{ char *cMove;
int n;
cMove=cNumber;
switch(i)
{case 2:
while((*cMove)!='\0')
{
if((*cMove)=='0'||(*cMove)=='1') {n=0;cMove++;}
else {printf("\n%s不是二进制数据,",cNumber);n=1;break;}
}
return(n);
break;
case 8:
while((*cMove)!='\0')
{
if((*cMove)>='0' && (*cMove)<='7') {n=0;cMove++;}
else {printf("\n%s不是八进制数据,",cNumber);n=1;break;}
}
return(n);
break;
case 10:
while((*cMove)!='\0')
{
if((*cMove)>='0' && (*cMove)<='9') {n=0;cMove++;}
else {printf("\n%s不是十进制数据,",cNumber);n=1;break;}
}
return(n);
break;
case 16:
while((*cMove)!='\0')
{
if(((*cMove)>='0' && (*cMove)<='9') || ((*cMove)>='A'&&(*cMove)<='F') || ((*cMove)>='a'&&(*cMove)<='f')) {n=0;cMove++;}
else {printf("\n%s不是十六进制数据,",cNumber);n=1;break;}
}
return(n);
break;
}//switch
}

F. c语言中的堆栈区变量区和汇编学的堆栈段代码段的区别

一个由C/C++编译的程序占用的内存分为以下几个部分
1、栈区（stack）
由编译器自动分配释放
，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap）
一般由程序员分配释放，
若程序员不释放，程序结束时可能由OS回收
。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，
未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。
-
程序结束后有系统释放
4、文字常量区
常量字符串就是放在这里的。
程序结束后由系统释放
5、程序代码区
存放函数体的二进制代码
汇编代码中的数据段、堆栈段、代码段、附加段具体指：
代码段,数据段,分别存入程序和数据
堆栈段是一块空白的空间用来为堆栈操作作准备
附加段是对数据段的补充
数据
有字节DB,字DW,双字DD,长字DQ和十字节变量DT
希望对你有所帮助，望点赞！！！

G. 求C语言堆栈代码。静态就行，只要有出，入，取栈顶就行了

typedef struct
{
DataType stack[MaxStackSize];
int top;
}SeqStack;
//初始化StackInitiate(S)
void StackInitiate(SeqStack *S) //初始化顺序堆栈S
{
S->top=0; //定义初始栈顶下标值
}
//非空否y(S)
int StackNotEmpty(SeqStack S)
//判断顺序堆栈S非空否，非空返回1，否则返回0
{
if(S.top<=0)
return 0;
else
return 1;
}
//入栈StackPush(SeqStack *S,DataType x)
int StackPush(SeqStack *S,DataType x)
//把数据元素值x压入顺序堆栈S，入栈成功返回1，否则返回0
{
if(S->top>=MaxStackSize)
{
printf("堆栈已满无法插入！\n");
return 0;
}
else
{
S->stack[S->top]=x;
S->top++;
return 1;
}
}
//出栈StackPop(SeqStack *S,DataType *d)
int StackPop(SeqStack *S,DataType *d)
//弹出顺序堆栈S的栈顶数据元素值到参数d，出栈成功返回1，否则返回0
{
if(S->top<=0)
{
printf("堆栈已空无数据元素出栈！\n");
return 0;
}
else
{
S->top--;
*d=S->stack[S->top];
return 1;
}
}
//取栈顶数据元素StackTop(SeqStack S,DataType *d)
int StackTop(SeqStack S,DataType *d)
//取顺序堆栈S的当前栈顶元素值到参数d，。成功返回1，否则返回0
{
if(S.top<=0)
{
printf("堆栈已空！\n");
return 0;
}
else
{
*d=S.stack[S.top-1];
return 1;
}
}

//测试代码
#include<stdio.h>
#include<stdlib.h>
#define MaxStackSize 100 //定义MaxStackSize为100
typedef int DataType;
#include"SeqStack.h"
void main(void)
{
SeqStack myStack;
int i,x;
StackInitiate(&myStack); //初始化
for(i=0;i<10;i++)
{
if(StackPush(&myStack,i+1)==0) //入栈10个数据元素
{
printf("错误！\n");
return ;
}
}
if(StackTop(myStack,&x)==0) //取栈顶数据元素
{
printf("错误！\n");
return ;
}
else
printf("当前栈顶数据元素为：%d\n",x);
printf("依次出栈的数据元素序列如下：\n");
while(StackNotEmpty(myStack))
{
StackPop(&myStack,&x); //出栈
printf("%d\t",x); //显示数据元素
}
}

H. 汇编中的堆栈段、代码段是什么是干吗的

lz知不知道什么叫段？段就是由寄存器指示的一段内存空间。
堆栈段：这段空间负责函数调用，比如所有局部变量都是存在于这里。
代码段：这段空间存储你的指令（指令不用解释了吧）。
图书：王爽的《汇编语言程序设计》或者杨季文《80x86汇编语言程序设计教程》
（名字不一定对，lz到google搜搜看）

I. 一段关于堆栈的代码，怎末实现不了啊，帮忙改改啊

你可以参考一下下面的代码：
#include <iostream.h>
class stack; //前向声明stack类
class node
{
private:
int data;
node *prev;
public:
node(int d,node *n)
{
data=d;
prev=n;
}
friend class stack; //定义友元类
};

class stack
{
private:
node *top;
public:
stack(){top=0;}
void push(int i);
int pop();
};
void stack::push (int i)
{
node *n=new node(i,top);
top=n;
}
int stack::pop ()
{
node *t=top;
if(top)
{
top=top->prev;
int c=t->data;
delete t;
return c;
}
return 0;
}
main()
{
int c;
stack s;
for(int j=0;j<10;++j)
{
cin>>c;
s.push (c);
}
for(j=0;j<10;++j)
cout<<s.pop ()<<" ";
cout<<endl;
return 1;
}

J. 电脑中堆栈代码执行攻击

如何查看程序的运行栈之~如果你认可我的回答，请及时点击【点赞为满意回答】按钮~~手机提问的朋友在客户端右上角评价点【满意】即可。~你的点赞是我前进的动力~~O(∩_∩)O，记得好评和点赞，互相帮助，谢谢。

阅读全文

堆栈代码

与堆栈代码相关的阅读推荐