# 计算机组成原理 

**Repository Path**: garfield_666/jisua

## Basic Information

- **Project Name**: 计算机组成原理 
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-06-14
- **Last Updated**: 2025-06-15

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# **项目 3：ALU算术逻辑仿真**

## 1.功能要求

* 支持以下运算：ADD, SUB, AND, OR, XOR, NOT
* 设计其编码格式、寄存器与内存结构。
* 不得使用标准库中的+、-、*等运算符（必须使用位运算模拟）

## 2.输入输出样例

```
Input: 5 AND 3  
Binary: 00000101 AND 00000011  
Result: 00000001

Input: NOT 6  
Binary: NOT 00000110  
Result: 11111001
```

## 3.工作分工

* 肖家浩(3231319204)：输入解析与操作符识别。

* 林洵有(3231319203)：逻辑运算模块（基于位运算）。

* 陈逸峰(3231319202)：格式化输出、异常处理与调试。

      

## 4.代码展示

```c
/*
功能要求：
支持以下运算：ADD, SUB, AND, OR, XOR, NOT
操作数为8位整数，结果输出为二进制字符串
不得使用标准库中的+、-、*等运算符（必须使用位运算模拟）

输入输出样例：
Input: 5 AND 3  
Binary: 00000101 AND 00000011  
Result: 00000001

Input: NOT 6  
Binary: NOT 00000110  
Result: 11111001
*/

#include <stdio.h>
#include <string.h>
#include <ctype.h>

#define BIT_WIDTH 8

// 8位加法器（不使用+号）
unsigned char add(unsigned char a, unsigned char b) {
    unsigned char carry;
    while (b != 0) {
        carry = a & b;
        a = a ^ b;
        b = carry << 1;
    }
    return a;
}

// 8位减法器（不使用-号，a-b = a+（~b+1））
unsigned char sub(unsigned char a, unsigned char b) {
    b = add(~b, 1); // 取补码
    return add(a, b);
}

// 8位与
unsigned char and_op(unsigned char a, unsigned char b) {
    return a & b;
}

// 8位或
unsigned char or_op(unsigned char a, unsigned char b) {
    return a | b;
}

// 8位异或
unsigned char xor_op(unsigned char a, unsigned char b) {
    return a ^ b;
}

// 8位非
unsigned char not_op(unsigned char a) {
    return ~a;
}

// 打印8位二进制
void print_bin(unsigned char n) {
    for (int i = BIT_WIDTH - 1; i >= 0; i--) {
        printf("%d", (n >> i) & 1);
    }
}

// 将字符串转换为大写
void to_upper(char *str) {
    for(int i = 0; str[i]; i++){
        str[i] = toupper(str[i]);
    }
}

// 检查数字是否在有效范围内
int is_valid_number(int num) {
    return num >= 0 && num <= 255;
}

int main() {
    char input[100];
    char op[10];
    int a, b;
    int running = 1;
    
    printf("8-bit Binary Calculator (输入'exit'退出)\n");
    printf("支持的操作: ADD, SUB, AND, OR, XOR, NOT\n");
    printf("注意: 输入数字必须在0-255范围内\n");

    while (running) {
        printf("\nInput: ");
        if (fgets(input, sizeof(input), stdin) == NULL) {
            printf("Error reading input.\n");
            break;
        }

        // 去除换行符
        input[strcspn(input, "\n")] = '\0';

        // 检查是否要退出
        if (strcmp(input, "exit") == 0) {
            running = 0;
            continue;
        }

        // 尝试解析 NOT 操作
        if (strncmp(input, "NOT", 3) == 0) {
            int num;
            if (sscanf(input, "NOT %d", &num) == 1) {
                if (!is_valid_number(num)) {
                    printf("Error: Number must be between 0 and 255\n");
                    continue;
                }
                printf("Binary: NOT ");
                print_bin((unsigned char)num);
                printf("\nResult: ");
                print_bin(not_op((unsigned char)num));
                printf("\n");
            } else {
                printf("Error: Invalid input format for NOT operation. Usage: NOT <number>\n");
            }
        } 
        // 尝试解析其他操作
        else {
            int temp_a, temp_b;
            char temp_op[10];
            if (sscanf(input, "%d %9s %d", &temp_a, temp_op, &temp_b) == 3) {
                if (!is_valid_number(temp_a) || !is_valid_number(temp_b)) {
                    printf("Error: Numbers must be between 0 and 255\n");
                    continue;
                }
                
                // 将操作符转换为大写
                to_upper(temp_op);
                strcpy(op, temp_op);

                printf("Binary: ");
                print_bin((unsigned char)temp_a);
                printf(" %s ", op);
                print_bin((unsigned char)temp_b);
                printf("\nResult: ");

                if (strcmp(op, "ADD") == 0) {
                    print_bin(add((unsigned char)temp_a, (unsigned char)temp_b));
                } else if (strcmp(op, "SUB") == 0) {
                    print_bin(sub((unsigned char)temp_a, (unsigned char)temp_b));
                } else if (strcmp(op, "AND") == 0) {
                    print_bin(and_op((unsigned char)temp_a, (unsigned char)temp_b));
                } else if (strcmp(op, "OR") == 0) {
                    print_bin(or_op((unsigned char)temp_a, (unsigned char)temp_b));
                } else if (strcmp(op, "XOR") == 0) {
                    print_bin(xor_op((unsigned char)temp_a, (unsigned char)temp_b));
                } else {
                    printf("Error: Invalid operator '%s'. Supported operators: ADD, SUB, AND, OR, XOR, NOT\n", op);
                }
                printf("\n");
            } 
            // 尝试解析NOT操作(另一种格式)
            else if (sscanf(input, "%9s %d", temp_op, &temp_a) == 2) {
                to_upper(temp_op);
                if (strcmp(temp_op, "NOT") == 0) {
                    if (!is_valid_number(temp_a)) {
                        printf("Error: Number must be between 0 and 255\n");
                        continue;
                    }
                    printf("Binary: NOT ");
                    print_bin((unsigned char)temp_a);
                    printf("\nResult: ");
                    print_bin(not_op((unsigned char)temp_a));
                    printf("\n");
                } else {
                    printf("Error: Invalid input format. Expected formats:\n"
                           "NOT <number>\n"
                           "<number> <operator> <number>\n"
                           "Supported operators: ADD, SUB, AND, OR, XOR, NOT\n");
                }
            } else {
                printf("Error: Invalid input format. Expected formats:\n"
                       "NOT <number>\n"
                       "<number> <operator> <number>\n"
                       "Supported operators: ADD, SUB, AND, OR, XOR, NOT\n"
                       "输入'exit'退出\n");
            }
        }
    }

    printf("程序已退出。\n");
    return 0;
}
```

运行方式：运行编译好的文件，文件提示：

```
8-bit Binary Calculator (输入'exit'退出)
支持的操作: ADD, SUB, AND, OR, XOR, NOT
注意: 输入数字必须在0-255范围内
```

输入

```
5 AND 3
```

输出

```
Binary: 00000101 AND 00000011  
Result: 00000001
```



## 5.原理解析

### a. 8位加法器原理（不使用+号）

*   基本思路​：通过位操作模拟加法过程，使用异或和与运算实现进位处理
​*   具体实现​：
*   carry = a & b：计算进位位，只有当a和b的对应位都为1时才会产生进位
*   a = a ^ b：计算无进位和，异或操作可以得到不考虑进位的加法结果
*   b = carry << 1：将进位左移一位，准备在下一次迭代中加到结果上
*   循环直到没有进位(b=0)为止

### b. 8位减法器原理（a-b = a+（~b+1））

*  基本思路​：利用补码原理，将减法转换为加法运算
*  ​具体实现​：
*  b = add(~b, 1)：计算b的补码（按位取反后加1）
*  return add(a, b)：将a与b的补码相加，等价于a-b 

------

### c. 其他位运算原理

*  与运算(AND)​​：

*  直接使用&运算符
*  两个操作数的对应位都为1时，结果的该位才为1
*  ​或运算(OR)​​：

*  直接使用|运算符
*  两个操作数的对应位只要有一个为1，结果的该位就为1
​*  异或运算(XOR)​​：

*  直接使用^运算符
*  两个操作数的对应位不同时，结果的该位为1
*  ​非运算(NOT)​​：

*  直接使用~运算符
*  操作数的每一位取反(0变1，1变0)

### d. 输入输出处理原理

*  ​​二进制转换​：

*  ​print_bin函数通过右移和掩码操作逐位提取数字的二进制表示
*  ​从最高位(BIT_WIDTH-1)到最低位(0)依次输出  


### e. 8位限制原理  

*  所有运算结果都被限制在8位范围内(0-255)
*  通过unsigned char类型保证数据宽度
*  超出范围的运算结果会被自动截断(高位丢弃)

## 6.总结

本程序实现了一个基于纯位操作的原生8位二进制计算器，通过循环进位算法（利用按位与计算进位、异或计算无进位和、左移传递进位）和补码转换机制（取反加一实现减法），完整模拟了计算机硬件中算术逻辑单元（ALU）的核心功能，在严格限制数据宽度为8位（0-255）的前提下，支持加、减、与、或、异或、非六种基础位运算；程序采用模块化设计，构建了清晰的运算函数体系，并通过灵活的命令行交互接口（支持二元/一元运算格式）与严格的输入验证机制（数值范围检查、操作符合法性验证）。