模拟8086cpu-微机原理与接口第二次作业

于 2024-10-01 19:40:02 发布
阅读量556 收藏 15
点赞数 9
分类专栏： 微机原理与接口 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75163580/article/details/142673726
版权

要求与规范：

基础组件定义：

寄存器：实现至少8个通用寄存器（如AX, BX, CX, DX, SP, BP, SI, DI）和一个指令寄存器（IR）、一个程序计数器（PC/IP，Instruction Pointer）。寄存器大小应设定为16位。

数据总线：定义一条16位的数据总线，用于CPU内部及CPU与外部存储器之间的数据传输。

控制单元：设计逻辑以解析指令，控制指令的执行流程，包括从内存中读取指令、解码指令、执行指令以及更新PC等。

内存：实现一个简单的内存模型，能够存储指令和数据，至少包含足够空间以加载和执行示例程序。

根据c语言特点，用结构体实现simple8086的类，也需要手动考虑一下用什么数据类型表示各个组件。内存这里实现的也不太理想，c里的字符串不是一个单独的数据类型，是字符数组，所以这里用的二维数组表示的。dalao说string不单独作为一个数据类型更好，我还不是dalao只想直接用string8个通用寄存器就是一个int型数组，为了方便起见我也不知道有没有真的方便到我，我想到宏定义各个数组的名称作为索引？其实总线的表示我觉得是很难模拟的，因为实际上并没有数据在传输。。。会在总线更新的函数里完善打印内容的。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>

#define MEMORY_SIZE 256
#define INSTRUCTION_SIZE 25
// 16位 8个通用寄存器 
#define AX 0
#define BX 1
#define CX 2
#define DX 3
#define SP 4 
#define BP 5
#define SI 6
#define DI 7
typedef struct{
	unsigned int ip;//指令指针 
	char memory[MEMORY_SIZE][INSTRUCTION_SIZE];
	int registers[8];
	
	int data_bus;
	bool control_bus_read;
	bool control_bus_write;
}simple8086;

指令集实现：

MOV指令：实现数据在寄存器之间的移动。例如，MOV AX, BX 会将BX寄存器的值复制到AX寄存器中。

ADD指令：实现两个寄存器之间的加法操作，并将结果存回其中一个寄存器。例如，ADD AX, BX 会将AX和BX的值相加，并将结果存回AX。

HLT指令：实现停机指令，当CPU执行到HLT指令时，应停止执行后续指令，模拟系统挂起或等待外部中断的状态。程序加载与执行：设计一种方式（如文本文件或硬编码）来加载和执行包含MOV、ADD、HLT等指令的示例程序。程序应能够连续执行指令，直到遇到HLT指令或程序结束。

这里就体现了宏定义寄存器和指令集有点蠢，此乃我觉得写一堆ifelse不好看就想写成switch的结果。但容我辩解，一直strcmp感觉也挺烦的。退一步讲其实应该都是机器码，不过我不知道怎么表示解释器这一步。

// 指令集 
#define MOV 0
#define ADD 1
#define HLT 2
void mov(simple8086* cpu,int* reg,int val){
	printf("将 %d 移动到寄存器AX",val);
	
	switch(*reg){
		case AX:
			cpu->registers[AX]=val;
			printf("将 %d 移动到寄存器AX\n",val);
			break;
		case BX:
			cpu->registers[BX]=val;
			printf("将 %d 移动到寄存器BX\n",val);
			break;
		case CX:
			cpu->registers[CX]=val;
			printf("将 %d 移动到寄存器CX\n",val);
			break;
		case DX:
			cpu->registers[DX]=val;
			printf("将 %d 移动到寄存器DX\n",val);
			break;
    } 
}

void add(simple8086* cpu,int* reg,int val){
	switch (*reg) {
		case AX:
			cpu->registers[AX]+=val;
			printf("给寄存器AX加上%d\n",val);
			break;
		case BX:
			cpu->registers[BX]+=val;
			printf("给寄存器BX加上%d\n",val);
			break;
		case CX:
			cpu->registers[CX]+=val;
			printf("给寄存器CX加上%d\n",val);
			break;
		case DX:
			cpu->registers[DX]+=val;
			printf("给寄存器DX加上%d\n",val);
			break;
		
	}
}

void hlt(){
	printf("停止执行\n");
	exit(0);
}

其实后面调试的时候发现一种我觉得更好的写法，非常滴简洁，我非常喜欢。

void mov(simple8086* cpu,int* reg,int* val){
 	printf("将 %d 移动到寄存器%s\n", 
           *val, *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" : "DX");
    cpu->registers[*reg] = *val;
}
void add(simple8086* cpu,int* reg,int* val){
    printf("给寄存器%s加上 %d\n", 
           *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" : "DX", *val);
    cpu->registers[*reg] += *val;
}
void hlt(){
	printf("...停止执行\n");
	exit(0);
}

调试与输出：

实现一种机制（如控制台输出）来显示每一步执行后的寄存器状态、内存内容以及当前执行的指令，以便于调试和观察CPU的工作过程。

这里就是简单的打印寄存器状态和总线状态的代码

// 显示寄存器状态
void print_reg(simple8086* cpu){
	printf("寄存器状态：\n");
	printf("\tAX: %d BX: %d CX: %d DX: %d SP: %d BP: %d SI: %d DI: %d\n\n",
			cpu->registers[AX],
			cpu->registers[BX],
			cpu->registers[CX],
			cpu->registers[DX],
			cpu->registers[SP],
			cpu->registers[BP],
			cpu->registers[SI],
			cpu->registers[DI]);
}

// 更新并显示总线状态 
void update_buses(simple8086* cpu,int* op,int* reg,int* val){
	printf("总线状态:\n");
	printf("地址总线：\n");
	switch(*op){
		case MOV:
			cpu->data_bus = *val;
			cpu->control_bus_read=true;
			cpu->control_bus_write=false;
			printf("\tSOURCE: %s DESTINATION: memory[%d]\n",
                   *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" : "DX",cpu->ip);
			break;
		case ADD:
			cpu->data_bus = *val;
			cpu->control_bus_read=false;
			cpu->control_bus_write=true;
			printf("\tSOURCE: %s DESTINATION: %s\n",
                   *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" :"DX",
                   *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" :"DX");
			break;
		case HLT:
			cpu->data_bus = 0;
			cpu->control_bus_read=false;
			cpu->control_bus_write=false;
			printf("HLT指令：停止执行\n");
			break;			
	}
	printf("\t控制总线:\n");
	printf("\t\tREAD：%s WRITE：%s\n",cpu->control_bus_read? "TRUE" : "FALSE",cpu->control_bus_write? "TRUE" : "FALSE");
	printf("\t数据总线:\n");
	printf("\t\tDATA:%d\n",cpu->data_bus);
}

关于指令的执行的打印输出感觉逻辑并不是很清楚，但姑且完成了。

void mov(simple8086* cpu,int* reg,int* val){
    printf("将 %d 移动到寄存器%s\n", *val, *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" :"DX");
    cpu->registers[*reg] = *val;
}

void add(simple8086* cpu,int* reg,int* val){
    printf("给寄存器%s加上 %d\n", *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" : "DX", *val);
    cpu->registers[*reg] += *val;
}

void hlt(){
	printf("...停止执行\n");
	exit(0);
}

static char instruction_buffer[INSTRUCTION_SIZE];
char* fetch(simple8086* cpu){
	strcpy(instruction_buffer,cpu->memory[cpu->ip]);
	printf("正在从内存地址 %u 获取指令：%s\n", cpu->ip, instruction_buffer);
	cpu->ip++;
	return instruction_buffer;
}

void decode(simple8086* cpu,char* instruction,int* op,int* reg,int* val){
	printf("正在解码指令..."); 
	/* 执行部分代码 */
	printf("操作码%s 寄存器%s 值%d\n",parts[0],parts[1],*val);
    /* 执行部分代码 */						
}
// 显示寄存器状态
void print_reg(simple8086* cpu){
	printf("寄存器状态：\n");
	printf("\tAX: %d BX: %d CX: %d DX: %d SP: %d BP: %d SI: %d DI: %d\n\n",
			cpu->registers[AX],
			cpu->registers[BX],
			cpu->registers[CX],
			cpu->registers[DX],
			cpu->registers[SP],
			cpu->registers[BP],
			cpu->registers[SI],
			cpu->registers[DI]);
}

// 更新并显示总线状态 
void update_buses(simple8086* cpu,int* op,int* reg,int* val){
	printf("总线状态:\n");
	printf("地址总线：\n");
	switch(*op){
		case MOV:
			/* 执行部分代码 */
			printf("\tSOURCE: %s DESTINATION: memory[%d]\n",
                   *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" : "DX",cpu->ip);
			break;
		case ADD:
			/* 执行部分代码 */
			printf("\tSOURCE: %s DESTINATION: %s\n",
                   *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" :"DX",
                   *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" :"DX");
			break;
		case HLT:
			/* 执行部分代码 */
			printf("HLT指令：停止执行\n");
			break;			
	}
	printf("\t控制总线:\n");
	printf("\t\tREAD：%s WRITE：%s\n",cpu->control_bus_read? "TRUE" : "FALSE",cpu->control_bus_write? "TRUE" : "FALSE");
	printf("\t数据总线:\n");
	printf("\t\tDATA:%d\n",cpu->data_bus);
} 


// 执行 
void execute(simple8086* cpu,int* op,int* reg,int* val) {
	printf("正在执行指令: %s...\n", 
	       *op == MOV ? "MOV" : *op == ADD ? "ADD" : *op == HLT ? "HLT" : "未知指令");
	/* 执行部分代码 */
	update_buses(cpu,op,reg,val);
	print_reg(cpu);
}

本次作业大量参考老师给出的python源码。

此乃参考代码的运行结果。
参考代码
此乃本次完成的代码结果。

在这里插入图片描述

从结果上来看已经基本完成需求了。不过操作码，寄存器和值是三个指针感觉好像不是很好，不过暂时没想到更好的办法，就先这样吧。

执行流程图

在这里插入图片描述

完整源码

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>
//内存大小及指令字长
#define MEMORY_SIZE 256
#define INSTRUCTION_SIZE 25

// 16位 8个通用寄存器 
#define AX 0
#define BX 1
#define CX 2
#define DX 3
#define SP 4 
#define BP 5
#define SI 6
#define DI 7
// 指令集 
#define MOV 0
#define ADD 1
#define HLT 2

typedef struct{
	unsigned int ip;//指令指针 
	char memory[MEMORY_SIZE][INSTRUCTION_SIZE];//字符串结尾有多余的“/0” 
	int registers[8];
	
	int data_bus;
	bool control_bus_read;
	bool control_bus_write;

}simple8086;

void mov(simple8086* cpu,int* reg,int* val){
    printf("将 %d 移动到寄存器%s\n", *val, *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" :"DX");
    cpu->registers[*reg] = *val;
}

void add(simple8086* cpu,int* reg,int* val){
    printf("给寄存器%s加上 %d\n", *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" : "DX", *val);
    cpu->registers[*reg] += *val;
}

void hlt(){
	printf("...停止执行\n");
	exit(0);
}

static char instruction_buffer[INSTRUCTION_SIZE];
char* fetch(simple8086* cpu){
	strcpy(instruction_buffer,cpu->memory[cpu->ip]);
	printf("正在从内存地址 %u 获取指令：%s\n", cpu->ip, instruction_buffer);
	cpu->ip++;
	return instruction_buffer;
}

void decode(simple8086* cpu,char* instruction,int* op,int* reg,int* val){
	printf("正在解码指令..."); 
	char parts[3][16];
	//sscanf从字符串中读取格式化输入的函数
	//sscanf返回成功接收到几个参数
	int part_count = sscanf(instruction,"%s %s %d",
							parts[0],parts[1],val);
	printf("操作码%s 寄存器%s 值%d\n",parts[0],parts[1],*val);
    //反向译码hhhh 我把字符串翻译成数字怎么不算译码呢 
	if(strcmp(parts[0],"MOV")==0) {*op = MOV;}
	else if(strcmp(parts[0],"ADD")==0){*op = ADD;/*printf("%d",*op);说明解码操作码没问题*/}
	else if(strcmp(parts[0],"HLT")==0){*op = HLT;}
	//printf("%d",part_count);>>>3
	if(part_count>=2){
		if(strcmp(parts[1],"AX")==0) {*reg = AX;}
		else if(strcmp(parts[1],"BX")==0){*reg = BX;}
		else if(strcmp(parts[1],"CX")==0){*reg = CX;/*printf("\n%d\n",*reg);*/}
		else if(strcmp(parts[1],"DX")==0){*reg = DX;}
	}						
}
// 显示寄存器状态
void print_reg(simple8086* cpu){
	printf("寄存器状态：\n");
	printf("\tAX: %d BX: %d CX: %d DX: %d SP: %d BP: %d SI: %d DI: %d\n\n",
			cpu->registers[AX],
			cpu->registers[BX],
			cpu->registers[CX],
			cpu->registers[DX],
			cpu->registers[SP],
			cpu->registers[BP],
			cpu->registers[SI],
			cpu->registers[DI]);
}

// 更新并显示总线状态 
void update_buses(simple8086* cpu,int* op,int* reg,int* val){
	printf("总线状态:\n");
	printf("地址总线：\n");
	switch(*op){
		case MOV:
			cpu->data_bus = *val;
			cpu->control_bus_read=true;
			cpu->control_bus_write=false;
			printf("\tSOURCE: %s DESTINATION: memory[%d]\n",
                   *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" : "DX",cpu->ip);
			break;
		case ADD:
			cpu->data_bus = *val;
			cpu->control_bus_read=false;
			cpu->control_bus_write=true;
			printf("\tSOURCE: %s DESTINATION: %s\n",
                   *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" :"DX",
                   *reg == AX ? "AX" : *reg == BX ? "BX" : *reg == CX ? "CX" :"DX");
			break;
		case HLT:
			cpu->data_bus = 0;
			cpu->control_bus_read=false;
			cpu->control_bus_write=false;
			printf("HLT指令：停止执行\n");
			break;			
	}
	printf("\t控制总线:\n");
	printf("\t\tREAD：%s WRITE：%s\n",cpu->control_bus_read? "TRUE" : "FALSE",cpu->control_bus_write? "TRUE" : "FALSE");
	printf("\t数据总线:\n");
	printf("\t\tDATA:%d\n",cpu->data_bus);
} 


// 执行 
void execute(simple8086* cpu,int* op,int* reg,int* val) {
	printf("正在执行指令: %s...\n", 
	       *op == MOV ? "MOV" : 
	       (*op == ADD ? "ADD" : 
	       (*op == HLT ? "HLT" : "未知指令")));
	switch(*op){
		case MOV:
			mov(cpu,reg,val);
			break;
		case ADD:
			add(cpu,reg,val);
			break;
		case HLT:
			hlt();
			break;
		default:
			printf("未知指令\n");
			break; 
	}
	update_buses(cpu,op,reg,val);
	print_reg(cpu);
}

void run(simple8086* cpu){
	printf("开始执行...\n");
	while(1){
		char* instruction = fetch(cpu);
		int* op = (int*) malloc(sizeof(int));
		int* reg = (int*) malloc(sizeof(int));
		int* val = (int*) malloc(sizeof(int));
		*op = 0;
		*reg = 0;
		*val = 0;
		decode(cpu,instruction,op,reg,val);
		execute(cpu,op,reg,val); 
		free(op);
		free(reg);
		free(val);
	} 
}

void Init_simple8086(simple8086 *cpu) {
    cpu->ip = 0;
    memset(cpu->memory, 0, sizeof(cpu->memory));
    memset(cpu->registers, 0, sizeof(cpu->registers));
    cpu->data_bus = 0;
    cpu->control_bus_read = false;
    cpu->control_bus_write = false;
}

int main(){
	simple8086 cpu;
	Init_simple8086(&cpu);
	strcpy(cpu.memory[0], "MOV AX 1");
	strcpy(cpu.memory[1], "ADD AX 2");
	strcpy(cpu.memory[2], "HLT");
	run(&cpu);
	return 0;
}
0takunek0
关注
专栏目录
微机原理与接口技术技术大题第二篇
高瑜的博客
11-19 1121
8086处理器的输入控制信号RESET、READY、HOLD的含义是什么？当他们有效时，8086CPU将出现何种反应？ RESET：复位输入信号，高电平有效。该引脚有效时，将迫使8086处理器回到初始状态，转为无效时，CPU重新开始工作。 READY：准备好信号，高电平有效的输入信号，表示存储器或I/O端口准备好，处理器的运行速度，远远快于存储器和I/O端口，当处理器检测到READY=0时，存储器或I/O端口不能按基本总线周期进行数据交换时，需要插入一个等待状态Tw，当处理器检测到READY=1时，可以进
微型计算机原理与接口技术朱金钧课后答案,微型计算机原理及应用技术 第3版...
weixin_31569663的博客
06-15 2085
图书简介配套资源：电子课件作者简介：朱金钧，教授，原河北科技大学信息科学与工程学院院长。曾任河北省电子学会副理事长，河北省计算机学会常务理事，河北省人工智能学会常务理事，河北省通讯学会常务理事，石家庄计算机学会理事长等社会兼职。主讲微型计算机原理及接口技术、计算机操作系统、计算机网络原理、嵌入式系统及计算机程序设计语言等课程。其中微型计算机原理及接口技术课程被评为河北省第一届省级精品课。本书特色：...
微机原理与接口技术-第二版-课后习题答案 绪论
中华儿女快起床了
08-06 3271
根据书上内容手敲········如果有用就点个赞吧~~ 绪论 1、模拟计算机和数字计算机的区别是什么？ 模拟计算机采用连续的模拟电信号表达信息，以运算放大器等模拟电路处理模拟电信号，计算精度取决于模拟器件，且必须通过手动更改模拟电路才能改变处理过程；数字计算机采用离散的数字量表达和处理信息，计算精度有保证，易于实现可编程控制。 2、计算机中存在的一个编码是00001001B，它代表什么？为什么？ 后缀B表示这采用了二进制编码，它代表无符号数9；它的原码、反码、补码都一样。 3、程序和指令有什么联
大学课程 | 《微机原理与接口技术》知识点总结
热门推荐
Justlovesmile的博客
07-22 5万+
文章目录第一章 微型计算机基础概论第一讲 关于第二讲 微型计算机系统组成第三讲 微机工作过程第四讲 常用数制第五讲 编码第六讲 数及其运算第七讲 基本逻辑运算和逻辑门第八讲 基本逻辑运算及其门电路第二章 微处理器与总线第九讲 8088/8086微处理器第十讲 8088的主要引线及其内部结构第十一讲 8088CPU内部寄存器第十二讲 实模式下的存储器寻址第十三讲 8088 系统总线第三章 指令系统概述第十四讲 8088/8086指令系统第十五讲 指令的寻址方式第十六讲 数据传送指令第四章 算术运算，逻辑运算与
微型计算机原理及应用 阶段作业,微机原理及应用第三次作业
weixin_35927281的博客
07-15 802
《微机原理及应用第三次作业》由会员分享，可在线阅读，更多相关《微机原理及应用第三次作业(3页珍藏版)》请在人人文库网上搜索。1、第三阶段作业一、填空题1.I/O接口信号分为数据信息、状态信息和( 控制信息 )等三类。2.接口与外设间的数据传输则可分为2种情况( 输入 )与( 输出 )。3.8255A根据端口选择信号A1、A0的组合把数据总线传送来的信息传送到相应的端口。当A1A010时，选中(端口...
微型计算机原理与接口技术ppt,单片机原理与接口技术课件ppt
weixin_28989315的博客
06-25 384
PPT内容这是单片机原理与接口技术课件ppt，包括了微型计算机基础，MCS-51单片机结构与时序，习题课，MCS-51与存储器连接示例，汇编语言程序设计，半导体存储器，中断系统，并行I/O接口，MCS-51串行通讯等内容，欢迎点击下载。单片机原理及接口技术课程安排40学时。上课共10周。课程设计一周。课程重点教材内容比较多，讲授1～9章内容，重点在MCS-51单片机原理、指令系统、单片机系统接口技...
微机原理与接口技术：微型计算机输入输出接口 详细笔记与例题
hanmo22357的博客
12-06 3058
按照数据信息传输方向划分：按照外设与CPU之间数据信息传输的方向，可以将外部设备分为输入设备、输出设备和复合输入输出设备。按照设备的功能划分：外设可以划分为人机交互设备、数据存储设备、媒体输入输出设备和数据采集与设备控制设备。 外部设备的信号分类：外部设备与主机之间交换的信号可以分为数据信号、控制信号和状态信号三类。三类信号都是以数据的形式，通过数据总线和CPU进行信息传输的。接口的定义：接口是计算机一个部件与另一个部件之间的连接界面。I/O接口的定义：计算机连接总线和外部设备的中间界面。I/O接口的功能：
微机原理与接口技术知识点整理
weixin_41555811的博客
11-18 1万+
本人：大学生一枚，只为分享经验知识。 微型计算机的体系结构： 主频：主时钟频率，CPU在单位时间内产生的时钟脉冲数。 执行部件EU，总线接口部件BIU，执行部件执行的同时，总线接口部件完成从存储器中预期后继指令的工作。 执行部件EU：负责全部指令的分析执行，并管理通用寄存器和标志寄存器。 通用寄存器组：包含4个数据寄存器（AX，BX，CX，DX），两个指针寄存器（BP，SP...
【微机原理与接口技术】微机原理与接口技术期末复习题
xtcc的博客
10-17 1564
1.数据传送三种方式：查询、中断和DMA 2.AD主要技术指标：分辨率、转换时间、量程、绝对精度、相对精度、线性度 3.接口课程中的芯片：中断控制器8259A、可编程并行接口8255A、可编程定时/计数器8253、可编程串行接口8251A 4.接口的功能 （1）对外部设备的寻址功能 （2）信号转换功能 （3）数据缓冲功能 （4）联络功能 （5）中断管理功能 （6）可编程功能 5.微机系统的性能指标 (1) CPU性能指标：字长、运算速度 总线宽度与字长；主频、MIPS与运算速度； 字长是CPU中运算器一次能
[网盘]微型计算机原理与接口技术（第四版）.pdf
03-20
### 微型计算机原理与接口技术（第四版） #### 知识点概览 本教材《微型计算机原理与接口技术》（第四版）由周荷琴等编著，是计算机科学与技术专业的重要课程之一。本书系统地介绍了微型计算机的工作原理、内部...
单片机微机原理与接口技术—基于STC15系列_课后习题答案.pdf
04-21
本资源涵盖了单片机微机原理与接口技术的基础知识和习题答案，涵盖了二进制数的原码、反码和补码、微型计算机的组成、8086的寻址范围、ROM、EPROM、EEPROM和FLASH、动态RAM和静态RAM、NOR FLASH和NAND FLASH等知识点...
微机系统与接口：第二次习题（复习）课.ppt
07-05
《微机系统与接口》是一门深入探讨计算机硬件与软件交互的学科，涵盖了微处理器、指令系统、存储器、接口技术和编程等多个方面。这门课程的复习内容主要包括以下几个关键知识点： 1. 微机系统基础：理解不同数制...
计算机微机组装与维护网上第二次作业答案.doc
07-07
17. 微型计算机发展史：主要围绕微处理器的发展，从8位到32位，再到64位的进化。 18. 存插槽：168线的内存插槽提供64位宽的数据传输。 19. 存：在执行应用程序时，CPU直接与内存交互，获取和存储数据。 20. 字的...
C语言 | 第四章 | 常量 运算符-1
ZJC744575的博客
09-28 1005
常量是固定值，在程序执行期间不能改变。这些固定的值，又叫做字面量。常量可以是任何的基本数据类型，比如整数常量、浮点常量、字符常量，或字符串字面值，也有枚举常量。常量的值在定义后不能进行修改使用 #define 预处理器。#define PI3.14//定义常量 PI 常量值3.14；后面可以不加；分号//PI = 3.1415 可以修改PI的值吗？答：不可以修改因为PI是常量// 提示左值必须是可以修改的值;就是说PI是不可以修改的//半径。
Codeforces Round 975 (Div. 2) C. Cards Partition
qq_36789020的博客
09-28 991
显然划分后每组牌数（即size）不超过n，那么要求size最大，只需要从n到1枚举size即可。对每个size，计算出还需要购买的牌数，跟k作比较即可。
前端初始化资源包初始化前端
10-01
.....................
vmware ubuntu22.04安装教程.docx
最新发布
10-01
vmware ubuntu22.04安装教程
语音处理相关的代码------matlab实现_______________开箱即用_soundProcess.zip
10-01
语音处理相关的代码------matlab实现_______________开箱即用_soundProcess
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值