CPU C++
2026-04-11 20:46:13
发布于:北京
本来的代码
/*
开发者:deepseek
检查:我
*/
#include <iostream>
#include <vector>
#include <cstdint>
#include <iomanip>
#include <map>
#include <string>
// ==================== 1. 逻辑门与全加器 ====================
// 基础逻辑门
inline bool AND(bool a, bool b) { return a & b; }
inline bool OR(bool a, bool b) { return a | b; }
inline bool XOR(bool a, bool b) { return a ^ b; }
inline bool NOT(bool a) { return !a; }
// 半加器
struct HalfAdder {
bool sum;
bool carry;
HalfAdder(bool a, bool b) {
sum = XOR(a, b);
carry = AND(a, b);
}
};
// 全加器
struct FullAdder {
bool sum;
bool carry_out;
FullAdder(bool a, bool b, bool carry_in) {
HalfAdder ha1(a, b);
HalfAdder ha2(ha1.sum, carry_in);
sum = ha2.sum;
carry_out = OR(ha1.carry, ha2.carry);
}
};
// 8位加法器(不使用+运算符)
uint8_t byte_add(uint8_t a, uint8_t b, bool& carry_out) {
uint8_t result = 0;
bool carry = 0;
for (int i = 0; i < 8; i++) {
bool bit_a = (a >> i) & 1;
bool bit_b = (b >> i) & 1;
FullAdder fa(bit_a, bit_b, carry);
if (fa.sum) result |= (1 << i);
carry = fa.carry_out;
}
carry_out = carry;
return result;
}
// ==================== 2. CPU 定义 ====================
enum class OpCode : uint8_t {
HALT, // 停机
LOAD, // 加载立即数到寄存器
ADD, // 加法
STORE, // 存储到内存
LOAD_M, // 从内存加载到寄存器
JMP, // 跳转
JE, // 相等跳转
JNE, // 不等跳转
CMP, // 比较
OUT, // 输出
NOP
};
// 指令结构
struct Instruction {
OpCode op;
uint8_t operand1;
uint8_t operand2;
};
// 8位CPU
class CPU8 {
private:
uint8_t reg_a; // 累加器
uint8_t reg_b; // 通用寄存器B
uint8_t reg_c; // 通用寄存器C
uint16_t pc; // 程序计数器
uint8_t flags; // 标志位: bit0=Z, bit1=C
std::vector<uint8_t> memory; // 64KB内存
bool running;
// 标志位操作
void set_zero_flag(uint8_t val) {
if (val == 0) flags |= 0x01;
else flags &= ~0x01;
}
void set_carry_flag(bool carry) {
if (carry) flags |= 0x02;
else flags &= ~0x02;
}
bool get_zero_flag() { return flags & 0x01; }
bool get_carry_flag() { return flags & 0x02; }
public:
CPU8() : reg_a(0), reg_b(0), reg_c(0), pc(0), flags(0), running(true) {
memory.resize(65536, 0); // 64KB内存
}
// 加载程序到内存
void load_program(const std::vector<uint8_t>& program, uint16_t start_addr) {
for (size_t i = 0; i < program.size(); i++) {
memory[start_addr + i] = program[i];
}
pc = start_addr;
}
// 写内存
void write_memory(uint16_t addr, uint8_t val) {
memory[addr] = val;
}
// 读内存
uint8_t read_memory(uint16_t addr) {
return memory[addr];
}
// 执行一条指令
void execute_instruction() {
if (pc >= memory.size()) {
running = false;
return;
}
uint8_t op_byte = memory[pc++];
OpCode op = static_cast<OpCode>(op_byte);
switch (op) {
case OpCode::HALT:
running = false;
break;
case OpCode::LOAD: {
uint8_t reg = memory[pc++];
uint8_t val = memory[pc++];
switch (reg) {
case 0: reg_a = val; break;
case 1: reg_b = val; break;
case 2: reg_c = val; break;
}
break;
}
case OpCode::ADD: {
uint8_t reg = memory[pc++];
uint8_t src_reg = memory[pc++];
uint8_t src_val;
switch (src_reg) {
case 0: src_val = reg_a; break;
case 1: src_val = reg_b; break;
case 2: src_val = reg_c; break;
default: src_val = 0;
}
bool carry_out;
uint8_t result;
switch (reg) {
case 0:
result = byte_add(reg_a, src_val, carry_out);
reg_a = result;
break;
case 1:
result = byte_add(reg_b, src_val, carry_out);
reg_b = result;
break;
case 2:
result = byte_add(reg_c, src_val, carry_out);
reg_c = result;
break;
}
set_zero_flag(result);
set_carry_flag(carry_out);
break;
}
case OpCode::STORE: {
uint8_t reg = memory[pc++];
uint16_t addr = memory[pc++];
addr |= (memory[pc++] << 8);
uint8_t val;
switch (reg) {
case 0: val = reg_a; break;
case 1: val = reg_b; break;
case 2: val = reg_c; break;
default: val = 0;
}
write_memory(addr, val);
break;
}
case OpCode::LOAD_M: {
uint8_t reg = memory[pc++];
uint16_t addr = memory[pc++];
addr |= (memory[pc++] << 8);
uint8_t val = read_memory(addr);
switch (reg) {
case 0: reg_a = val; break;
case 1: reg_b = val; break;
case 2: reg_c = val; break;
}
break;
}
case OpCode::JMP: {
uint16_t addr = memory[pc++];
addr |= (memory[pc++] << 8);
pc = addr;
break;
}
case OpCode::JE: {
uint16_t addr = memory[pc++];
addr |= (memory[pc++] << 8);
if (get_zero_flag()) pc = addr;
break;
}
case OpCode::JNE: {
uint16_t addr = memory[pc++];
addr |= (memory[pc++] << 8);
if (!get_zero_flag()) pc = addr;
break;
}
case OpCode::CMP: {
uint8_t reg1 = memory[pc++];
uint8_t reg2 = memory[pc++];
uint8_t val1, val2;
switch (reg1) {
case 0: val1 = reg_a; break;
case 1: val1 = reg_b; break;
case 2: val1 = reg_c; break;
}
switch (reg2) {
case 0: val2 = reg_a; break;
case 1: val2 = reg_b; break;
case 2: val2 = reg_c; break;
}
bool dummy;
uint8_t result = byte_add(val1, ~val2 + 1, dummy);
set_zero_flag(result);
break;
}
case OpCode::OUT: {
uint8_t reg = memory[pc++];
uint8_t val;
switch (reg) {
case 0: val = reg_a; break;
case 1: val = reg_b; break;
case 2: val = reg_c; break;
}
std::cout << static_cast<int>(val) << std::endl;
break;
}
case OpCode::NOP:
break;
}
}
// 运行CPU
void run() {
while (running) {
execute_instruction();
}
}
// 调试:打印寄存器状态
void debug() {
std::cout << "A=" << (int)reg_a << " B=" << (int)reg_b << " C=" << (int)reg_c
<< " PC=" << pc << " FLAGS=" << std::hex << (int)flags << std::dec << std::endl;
}
void reset() {
reg_a = reg_b = reg_c = 0;
pc = 0;
flags = 0;
running = true;
}
};
// ==================== 3. 汇编器 ====================
class Assembler {
private:
std::map<std::string, OpCode> op_map = {
{"HALT", OpCode::HALT},
{"LOAD", OpCode::LOAD},
{"ADD", OpCode::ADD},
{"STORE", OpCode::STORE},
{"LOAD_M", OpCode::LOAD_M},
{"JMP", OpCode::JMP},
{"JE", OpCode::JE},
{"JNE", OpCode::JNE},
{"CMP", OpCode::CMP},
{"OUT", OpCode::OUT},
{"NOP", OpCode::NOP}
};
std::map<std::string, uint8_t> reg_map = {
{"A", 0}, {"B", 1}, {"C", 2}
};
std::map<std::string, uint16_t> labels;
std::vector<std::string> tokenize(const std::string& line) {
std::vector<std::string> tokens;
std::string token;
for (char c : line) {
if (c == ' ' || c == '\t' || c == ',' || c == '\n') {
if (!token.empty()) {
tokens.push_back(token);
token.clear();
}
if (c == ',' || c == '\n') {
// 忽略逗号和换行
}
} else {
token += c;
}
}
if (!token.empty()) tokens.push_back(token);
return tokens;
}
public:
// 汇编代码转换为机器码
std::vector<uint8_t> assemble(const std::vector<std::string>& source) {
std::vector<uint8_t> code;
std::vector<std::pair<std::string, uint16_t>> label_defs;
// 第一遍:收集标签地址
uint16_t addr = 0;
for (const auto& line : source) {
if (line.empty() || line[0] == ';') continue;
auto tokens = tokenize(line);
if (tokens.empty()) continue;
// 检查是否是标签
if (tokens[0].back() == ':') {
std::string label = tokens[0].substr(0, tokens[0].size() - 1);
label_defs.push_back({label, addr});
// 标签行可能还有指令,继续处理
if (tokens.size() > 1) {
tokens.erase(tokens.begin());
} else {
continue;
}
}
// 计算指令长度
std::string op = tokens[0];
if (op_map.find(op) != op_map.end()) {
switch (op_map[op]) {
case OpCode::HALT: case OpCode::NOP:
addr += 1;
break;
case OpCode::LOAD: case OpCode::ADD: case OpCode::CMP:
addr += 3; // op + reg + val/reg
break;
case OpCode::STORE: case OpCode::LOAD_M: case OpCode::JMP:
case OpCode::JE: case OpCode::JNE:
addr += 4; // op + reg/addr + addr_lo + addr_hi
break;
case OpCode::OUT:
addr += 2;
break;
default:
break;
}
}
}
// 建立标签映射
for (const auto& [label, address] : label_defs) {
labels[label] = address;
}
// 第二遍:生成机器码
addr = 0;
for (const auto& line : source) {
if (line.empty() || line[0] == ';') continue;
auto tokens = tokenize(line);
if (tokens.empty()) continue;
// 跳过标签
if (tokens[0].back() == ':') {
if (tokens.size() > 1) {
tokens.erase(tokens.begin());
} else {
continue;
}
}
std::string op = tokens[0];
auto it = op_map.find(op);
if (it == op_map.end()) {
std::cerr << "Unknown opcode: " << op << std::endl;
continue;
}
OpCode opcode = it->second;
code.push_back(static_cast<uint8_t>(opcode));
switch (opcode) {
case OpCode::HALT:
case OpCode::NOP:
break;
case OpCode::LOAD:
case OpCode::ADD:
case OpCode::CMP: {
if (tokens.size() < 3) break;
uint8_t reg = reg_map[tokens[1]];
code.push_back(reg);
if (tokens[2][0] >= '0' && tokens[2][0] <= '9') {
uint8_t val = static_cast<uint8_t>(std::stoi(tokens[2]));
code.push_back(val);
} else {
uint8_t reg2 = reg_map[tokens[2]];
code.push_back(reg2);
}
break;
}
case OpCode::OUT: {
uint8_t reg = reg_map[tokens[1]];
code.push_back(reg);
break;
}
case OpCode::STORE:
case OpCode::LOAD_M: {
if (tokens.size() < 3) break;
uint8_t reg = reg_map[tokens[1]];
code.push_back(reg);
uint16_t addr_val;
if (tokens[2][0] >= '0' && tokens[2][0] <= '9') {
addr_val = static_cast<uint16_t>(std::stoi(tokens[2]));
} else {
addr_val = labels[tokens[2]];
}
code.push_back(addr_val & 0xFF);
code.push_back((addr_val >> 8) & 0xFF);
break;
}
case OpCode::JMP:
case OpCode::JE:
case OpCode::JNE: {
uint16_t addr_val = labels[tokens[1]];
code.push_back(addr_val & 0xFF);
code.push_back((addr_val >> 8) & 0xFF);
break;
}
default:
break;
}
}
return code;
}
};
// ==================== 4. 主程序:计算 A+B ====================
int main() {
std::cout << "=== 大炮打蚊子法:CPU模拟器计算 A+B ===" << std::endl;
std::cout << "输入两个数字 A 和 B:" << std::endl;
int a, b;
std::cin >> a >> b;
// 汇编程序:计算 A+B 并输出
std::vector<std::string> assembly = {
"; 程序:计算 A+B",
"; 输入 A 和 B 存储在内存地址 0x1000 和 0x1001",
"",
"START:",
" LOAD A, 0 ; 临时用立即数,实际应该从内存读",
" STORE A, 0x1000 ; 存储到内存(实际应从输入获取)",
" LOAD B, 0",
" STORE B, 0x1001",
"",
" LOAD_M A, 0x1000 ; 加载 A 到寄存器 A",
" LOAD_M B, 0x1001 ; 加载 B 到寄存器 B",
" ADD A, B ; A = A + B(用全加器实现)",
" OUT A ; 输出结果",
" HALT"
};
// 修改汇编代码,把立即数改成实际输入
std::vector<std::string> real_assembly;
for (const auto& line : assembly) {
if (line.find("LOAD A, 0") != std::string::npos) {
real_assembly.push_back(" LOAD A, " + std::to_string(a));
} else if (line.find("LOAD B, 0") != std::string::npos) {
real_assembly.push_back(" LOAD B, " + std::to_string(b));
} else {
real_assembly.push_back(line);
}
}
// 汇编
Assembler assembler;
auto machine_code = assembler.assemble(real_assembly);
std::cout << "\n生成的机器码(" << machine_code.size() << " 字节):";
for (uint8_t byte : machine_code) {
std::cout << " " << std::hex << std::setw(2) << std::setfill('0') << (int)byte;
}
std::cout << std::dec << std::endl << std::endl;
// 创建CPU并运行
CPU8 cpu;
cpu.load_program(machine_code, 0x0000);
std::cout << "运行结果:";
cpu.run();
std::cout << "\n\n计算完成!" << std::endl;
return 0;
}
结果。。。
=== 大炮打蚊子法:CPU模拟器计算 A+B ===
输入两个数字 A 和 B:
1 2
生成的机器码(28 字节): 01 00 01 03 00 00 00 01 01 02 03 01 00 00 04 00 00 00 04 01 00 00 02 00 01 09 00 00
运行结果:4
计算完成!
1+2=4???
#include <iostream>
#include <vector>
#include <cstdint>
#include <iomanip>
#include <map>
#include <string>
#include <sstream>
// ==================== 1. 逻辑门与全加器 ====================
inline bool AND(bool a, bool b) { return a & b; }
inline bool OR(bool a, bool b) { return a | b; }
inline bool XOR(bool a, bool b) { return a ^ b; }
inline bool NOT(bool a) { return !a; }
struct HalfAdder {
bool sum;
bool carry;
HalfAdder(bool a, bool b) {
sum = XOR(a, b);
carry = AND(a, b);
}
};
struct FullAdder {
bool sum;
bool carry_out;
FullAdder(bool a, bool b, bool carry_in) {
HalfAdder ha1(a, b);
HalfAdder ha2(ha1.sum, carry_in);
sum = ha2.sum;
carry_out = OR(ha1.carry, ha2.carry);
}
};
// 正确的 8 位加法器(不使用 + 运算符)
uint8_t byte_add(uint8_t a, uint8_t b, bool& carry_out) {
uint8_t result = 0;
bool carry = 0;
for (int i = 0; i < 8; i++) {
bool bit_a = (a >> i) & 1;
bool bit_b = (b >> i) & 1;
FullAdder fa(bit_a, bit_b, carry);
if (fa.sum) result |= (1 << i);
carry = fa.carry_out;
}
carry_out = carry;
return result;
}
// ==================== 2. CPU 定义 ====================
enum class OpCode : uint8_t {
HALT = 0x00,
LOAD = 0x01,
ADD = 0x02,
STORE = 0x03,
LOAD_M = 0x04,
JMP = 0x05,
JE = 0x06,
JNE = 0x07,
CMP = 0x08,
OUT = 0x09,
NOP = 0x0A
};
class CPU8 {
private:
uint8_t reg_a;
uint8_t reg_b;
uint8_t reg_c;
uint16_t pc;
uint8_t flags;
std::vector<uint8_t> memory;
bool running;
void set_zero_flag(uint8_t val) {
if (val == 0) flags |= 0x01;
else flags &= ~0x01;
}
void set_carry_flag(bool carry) {
if (carry) flags |= 0x02;
else flags &= ~0x02;
}
bool get_zero_flag() { return (flags & 0x01) != 0; }
bool get_carry_flag() { return (flags & 0x02) != 0; }
public:
CPU8() : reg_a(0), reg_b(0), reg_c(0), pc(0), flags(0), running(true) {
memory.resize(65536, 0);
}
void load_program(const std::vector<uint8_t>& program, uint16_t start_addr) {
for (size_t i = 0; i < program.size(); i++) {
memory[start_addr + i] = program[i];
}
pc = start_addr;
}
void write_memory(uint16_t addr, uint8_t val) {
memory[addr] = val;
}
uint8_t read_memory(uint16_t addr) {
return memory[addr];
}
void set_register(uint8_t reg, uint8_t val) {
switch (reg) {
case 0: reg_a = val; break;
case 1: reg_b = val; break;
case 2: reg_c = val; break;
}
}
uint8_t get_register(uint8_t reg) {
switch (reg) {
case 0: return reg_a;
case 1: return reg_b;
case 2: return reg_c;
default: return 0;
}
}
void execute_instruction() {
if (pc >= memory.size()) {
running = false;
return;
}
uint8_t op_byte = memory[pc++];
OpCode op = static_cast<OpCode>(op_byte);
switch (op) {
case OpCode::HALT:
running = false;
break;
case OpCode::LOAD: {
uint8_t reg = memory[pc++];
uint8_t val = memory[pc++];
set_register(reg, val);
break;
}
case OpCode::ADD: {
uint8_t dest_reg = memory[pc++];
uint8_t src_reg = memory[pc++];
uint8_t src_val = get_register(src_reg);
uint8_t dest_val = get_register(dest_reg);
bool carry_out;
uint8_t result = byte_add(dest_val, src_val, carry_out);
set_register(dest_reg, result);
set_zero_flag(result);
set_carry_flag(carry_out);
break;
}
case OpCode::STORE: {
uint8_t reg = memory[pc++];
uint16_t addr = memory[pc++];
addr |= (memory[pc++] << 8);
write_memory(addr, get_register(reg));
break;
}
case OpCode::LOAD_M: {
uint8_t reg = memory[pc++];
uint16_t addr = memory[pc++];
addr |= (memory[pc++] << 8);
set_register(reg, read_memory(addr));
break;
}
case OpCode::JMP: {
uint16_t addr = memory[pc++];
addr |= (memory[pc++] << 8);
pc = addr;
break;
}
case OpCode::JE: {
uint16_t addr = memory[pc++];
addr |= (memory[pc++] << 8);
if (get_zero_flag()) pc = addr;
break;
}
case OpCode::JNE: {
uint16_t addr = memory[pc++];
addr |= (memory[pc++] << 8);
if (!get_zero_flag()) pc = addr;
break;
}
case OpCode::CMP: {
uint8_t reg1 = memory[pc++];
uint8_t reg2 = memory[pc++];
uint8_t val1 = get_register(reg1);
uint8_t val2 = get_register(reg2);
bool dummy;
uint8_t result = byte_add(val1, ~val2 + 1, dummy);
set_zero_flag(result);
break;
}
case OpCode::OUT: {
uint8_t reg = memory[pc++];
std::cout << static_cast<int>(get_register(reg));
break;
}
case OpCode::NOP:
break;
}
}
void run() {
while (running) {
execute_instruction();
}
}
void reset() {
reg_a = reg_b = reg_c = 0;
pc = 0;
flags = 0;
running = true;
}
};
// ==================== 3. 汇编器 ====================
class Assembler {
private:
std::map<std::string, OpCode> op_map = {
{"HALT", OpCode::HALT},
{"LOAD", OpCode::LOAD},
{"ADD", OpCode::ADD},
{"STORE", OpCode::STORE},
{"LOAD_M", OpCode::LOAD_M},
{"JMP", OpCode::JMP},
{"JE", OpCode::JE},
{"JNE", OpCode::JNE},
{"CMP", OpCode::CMP},
{"OUT", OpCode::OUT},
{"NOP", OpCode::NOP}
};
std::map<std::string, uint8_t> reg_map = {
{"A", 0}, {"B", 1}, {"C", 2}
};
std::map<std::string, uint16_t> labels;
std::vector<std::string> tokenize(const std::string& line) {
std::vector<std::string> tokens;
std::string token;
for (char c : line) {
if (c == ' ' || c == '\t' || c == ',' || c == '\n' || c == '\r') {
if (!token.empty()) {
tokens.push_back(token);
token.clear();
}
} else {
token += c;
}
}
if (!token.empty()) tokens.push_back(token);
return tokens;
}
bool is_number(const std::string& s) {
if (s.empty()) return false;
for (char c : s) {
if (!isdigit(c)) return false;
}
return true;
}
public:
std::vector<uint8_t> assemble(const std::vector<std::string>& source) {
std::vector<uint8_t> code;
std::vector<std::pair<std::string, uint16_t>> label_defs;
// 第一遍:收集标签地址
uint16_t addr = 0;
for (const auto& line : source) {
std::string trimmed = line;
size_t comment_pos = trimmed.find(';');
if (comment_pos != std::string::npos) {
trimmed = trimmed.substr(0, comment_pos);
}
if (trimmed.empty()) continue;
auto tokens = tokenize(trimmed);
if (tokens.empty()) continue;
// 检查是否是标签
if (tokens[0].back() == ':') {
std::string label = tokens[0].substr(0, tokens[0].size() - 1);
label_defs.push_back({label, addr});
if (tokens.size() > 1) {
tokens.erase(tokens.begin());
} else {
continue;
}
}
// 计算指令长度
std::string op = tokens[0];
if (op_map.find(op) != op_map.end()) {
switch (op_map[op]) {
case OpCode::HALT: case OpCode::NOP:
addr += 1;
break;
case OpCode::LOAD: case OpCode::ADD: case OpCode::CMP: case OpCode::OUT:
addr += 3;
break;
case OpCode::STORE: case OpCode::LOAD_M:
addr += 4;
break;
case OpCode::JMP: case OpCode::JE: case OpCode::JNE:
addr += 3;
break;
default:
addr += 1;
break;
}
}
}
// 建立标签映射
for (const auto& [label, address] : label_defs) {
labels[label] = address;
}
// 第二遍:生成机器码
addr = 0;
for (const auto& line : source) {
std::string trimmed = line;
size_t comment_pos = trimmed.find(';');
if (comment_pos != std::string::npos) {
trimmed = trimmed.substr(0, comment_pos);
}
if (trimmed.empty()) continue;
auto tokens = tokenize(trimmed);
if (tokens.empty()) continue;
// 跳过标签行
if (tokens[0].back() == ':') {
if (tokens.size() > 1) {
tokens.erase(tokens.begin());
} else {
continue;
}
}
std::string op = tokens[0];
auto it = op_map.find(op);
if (it == op_map.end()) {
std::cerr << "Unknown opcode: " << op << std::endl;
continue;
}
OpCode opcode = it->second;
code.push_back(static_cast<uint8_t>(opcode));
addr++;
switch (opcode) {
case OpCode::HALT:
case OpCode::NOP:
break;
case OpCode::LOAD:
case OpCode::ADD:
case OpCode::CMP: {
if (tokens.size() < 3) break;
uint8_t dest_reg = reg_map[tokens[1]];
code.push_back(dest_reg);
addr++;
// 第二个操作数:可能是立即数或寄存器
if (is_number(tokens[2])) {
uint8_t val = static_cast<uint8_t>(std::stoi(tokens[2]));
code.push_back(val);
} else {
uint8_t src_reg = reg_map[tokens[2]];
code.push_back(src_reg);
}
addr++;
break;
}
case OpCode::OUT: {
if (tokens.size() < 2) break;
uint8_t reg = reg_map[tokens[1]];
code.push_back(reg);
addr++;
code.push_back(0); // 占位
addr++;
break;
}
case OpCode::STORE:
case OpCode::LOAD_M: {
if (tokens.size() < 3) break;
uint8_t reg = reg_map[tokens[1]];
code.push_back(reg);
addr++;
uint16_t addr_val;
if (is_number(tokens[2])) {
addr_val = static_cast<uint16_t>(std::stoi(tokens[2]));
} else {
addr_val = labels[tokens[2]];
}
code.push_back(addr_val & 0xFF);
code.push_back((addr_val >> 8) & 0xFF);
addr += 2;
break;
}
case OpCode::JMP:
case OpCode::JE:
case OpCode::JNE: {
if (tokens.size() < 2) break;
uint16_t addr_val = labels[tokens[1]];
code.push_back(addr_val & 0xFF);
code.push_back((addr_val >> 8) & 0xFF);
addr += 2;
break;
}
default:
break;
}
}
return code;
}
};
// ==================== 4. 主程序:计算 A+B ====================
int main() {
std::cout << "=== 大炮打蚊子法:CPU模拟器计算 A+B ===" << std::endl;
std::cout << "输入两个数字 A 和 B:";
int a, b;
std::cin >> a >> b;
// 生成汇编代码(使用立即数直接加载)
std::vector<std::string> assembly = {
"; 程序:计算 A+B",
"; 直接加载立即数到寄存器,然后相加输出",
"",
"START:",
" LOAD A, " + std::to_string(a),
" LOAD B, " + std::to_string(b),
" ADD A, B",
" OUT A",
" HALT"
};
// 汇编
Assembler assembler;
auto machine_code = assembler.assemble(assembly);
std::cout << "\n生成的机器码(" << machine_code.size() << " 字节):";
for (uint8_t byte : machine_code) {
std::cout << " " << std::hex << std::setw(2) << std::setfill('0') << (int)byte;
}
std::cout << std::dec << std::endl << std::endl;
// 创建CPU并运行
CPU8 cpu;
cpu.load_program(machine_code, 0x0000);
std::cout << "运行结果:" << a << " + " << b << " = ";
cpu.run();
std::cout << std::endl;
std::cout << "\n计算完成!" << std::endl;
return 0;
}
这里空空如也

















有帮助,赞一个