汇编代码生成和编译器的后端

news2024/9/27 21:27:27

1.前置程序：语义分析和中间代码生成

基于SLR(1)分析的语义分析及中间代码生成程序-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/lijj0304/article/details/135097554?spm=1001.2014.3001.5501

2.程序目标

在前面编译器前端实现的基础上，将所生成的中间代码翻译成某种目标机的汇编代码，实现编译器后端实现的任务。然后进一步实现程序的输入是源程序，输出是汇编语言目标代码小型实验语言编译器。最终程序是实现了算式的识别和汇编代码生成的功能

3.主要数据结构

生成汇编代码用到的寄存器我直接用字符串来实现，因为寄存器仅需要存储变量名即可

char rs0[MAX_LEN];  
char rs1[MAX_LEN]; // 设置两个寄存器  
rs0[0] = '\0';  
rs1[0] = '\0';

对于四元式构造了一个专门的数据结构来存储他的四个变量，同时构建一个四元式的数组来管理，四元式数组的大小刚好也对应了中间变量的数量。

struct quadruple {
    char op[MAX_LEN];
    char arg1[MAX_LEN];
    char arg2[MAX_LEN];
    char result[MAX_LEN];
}; // 四元式数据结构

3.程序描述

先初始化了两个寄存器R0和R1，如何通过遍历四元式的数据结构数组来生成汇编代码。主要思路是先考虑寄存器中的值，即这个四元式中是否有变量存储在了R0或者R1中。

int flag = 0; // flag为0表示两个寄存器都空闲，1表示找到第一个操作数，2表示找到第二个操作数, 3表示两个操作数都找到  
int tag = -1; // tag为0表示值在rs0，1表示值在rs1  
if((strcmp(rs0, quad[i].arg1) == 0 && strcmp(rs1, quad[i].arg2) == 0) || (strcmp(rs0, quad[i].arg2) == 0 && strcmp(rs1, quad[i].arg1) == 0)) {  
    flag = 3;  
}  
else if(strcmp(rs0, quad[i].arg1) == 0) {  
    flag = 1, tag = 0;  
}  
else if(strcmp(rs1, quad[i].arg1) == 0) {  
    flag = 1, tag = 1;  
}  
else if(strcmp(rs0, quad[i].arg2) == 0) {  
    flag = 2, tag = 0;  
}  
else if(strcmp(rs1, quad[i].arg2) == 0) {  
    flag = 2, tag = 1;  
}

在生成了对应四元式的汇编代码后，还需考虑这个结果值是是否在之后要被使用若不需要使用则可以直接把寄存器置空。

int use0(int p) { // 判断是否还会用到寄存器rs0内容
    for(int i = p; i <= quadTop; i++) {
        if(strcmp(quad[i].arg1, rs0) == 0 || strcmp(quad[i].arg2, rs0) == 0) {
            return 1;
        }
    }
    return 0;
}
int use1(int p) { // 判断是否还会用到寄存器rs1内容
    for(int i = p; i <= quadTop; i++) {
        if(strcmp(quad[i].arg1, rs1) == 0 || strcmp(quad[i].arg2, rs1) == 0) {
            return 1;
        }
    }
    return 0;
}

若寄存器R0和R1都不含有变量，则需要找空的及存储变量，若没有可用寄存器则需要报错

        if(flag == 0) {
            if(rs0[0] == '\0') {
                printf("MOV R0, %s\n", quad[i].arg1);
                printf("%s R0, %s\n", opstr, quad[i].arg2);
                strcpy(rs0, quad[i].result);
                if(use0(i + 1) == 0) {
                    rs0[0] = '\0';
                }
            }
            else if(rs1[0] == '\0') {
                printf("MOV R1, %s\n", quad[i].arg1);
                printf("%s R1, %s\n", opstr, quad[i].arg2);
                strcpy(rs1, quad[i].result);
                if(use1(i + 1) == 0) {
                    rs1[0] = '\0';
                }
            }
            else {
                printf("Assembly failed\n");
                return;
            }
        }

如果R0和R1中有变量，则直接操作对应寄存器，生成代码即可

        else if(flag == 2) {
            if(tag == 0) {
                printf("%s R0, %s\n", opstr, quad[i].arg1);
                strcpy(rs0, quad[i].result);
                if(use0(i + 1) == 0) {
                    rs0[0] = '\0';
                }
            }
            else {
                printf("%s R1, %s\n", opstr, quad[i].arg1);
                strcpy(rs1, quad[i].result);
                if(use1(i + 1) == 0) {
                    rs1[0] = '\0';
                }
            }
        }
        else if(flag == 3) {
            if(use0(i + 1) == 0) {
                printf("%s R0, R1\n", opstr);
                strcpy(rs0, quad[i].result);
            }
            else {
                printf("%s R1, R0\n", opstr);
                strcpy(rs1, quad[i].result);
            }
        }
    }

4.完整代码

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAX_LEN 1000

struct stack {
    char s[MAX_LEN];
    int i[MAX_LEN];
    int point[MAX_LEN];
    int top;
}; // 分析栈数据结构

struct quadruple {
    char op[MAX_LEN];
    char arg1[MAX_LEN];
    char arg2[MAX_LEN];
    char result[MAX_LEN];
}; // 四元式数据结构

struct quadruple quad[MAX_LEN]; // 存储四元式
int quadTop = 0; // 四元式栈顶

char rs0[MAX_LEN];
char rs1[MAX_LEN]; // 设置两个寄存器

// 1.S→V=E  2.E→E+T  3.E→E-T  4.E→T  5.T→T*F  6.T→T/F  7.T→F  8.F→(E) 9.F→i  10.V→i
// 表中大于0对应移进，小于0则对应先归约后移进，0为不存在的状态
                    //          GOTO           |    ACTION
                    //i, =, +, -, *, /, (, ), #, S, E, T, F, V
int table[20][14] ={{ 3, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2},// 0
                    { 0, 0, 0, 0, 0, 0, 0, 0,-11,0,0, 0, 0, 0},// 1
                    { 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},// 2
                    {-10,-10,-10,-10,-10,-10,-10,-10,-10, 0, 0, 0, 0, 0},//3
                    { 9, 0, 0, 0, 0, 0, 8, 0, 0, 0, 5, 6, 7, 0},// 4
                    {-1,-1,10,11,-1,-1,-1,-1,-1, 0, 0, 0, 0, 0},// 5
                    {-4,-4,-4,-4,12,13,-4,-4,-4, 0, 0, 0, 0, 0},// 6
                    {-7,-7,-7,-7,-7,-7,-7,-7,-7, 0, 0, 0, 0, 0},// 7
                    { 9, 0, 0, 0, 0, 0, 8, 0, 0, 0,14, 6, 7, 0},// 8
                    {-9,-9,-9,-9,-9,-9,-9,-9,-9, 0, 0, 0, 0, 0},// 9
                    { 9, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0,15, 7, 0},//10
                    { 9, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0,16, 7, 0},//11
                    { 9, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0,17, 0},//12
                    { 9, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0,18, 0},//13
                    { 0, 0,10,11, 0, 0, 0,19, 0, 0, 0, 0, 0, 0},//14
                    {-2,-2,-2,-2,12,13,-2,-2,-2, 0, 0, 0, 0, 0},//15
                    {-3,-3,-3,-3,12,13,-3,-3,-3, 0, 0, 0, 0, 0},//16
                    {-5,-5,-5,-5,-5,-5,-5,-5,-5, 0, 0, 0, 0, 0},//17
                    {-6,-6,-6,-6,-6,-6,-6,-6,-6, 0, 0, 0, 0, 0},//18
                    {-8,-8,-8,-8,-8,-8,-8,-8,-8, 0, 0, 0, 0, 0}};//19

int english(char ch) {
	if((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) return 1;
	else return 0;
}
int number(char ch) {
	if(ch >= '0' && ch <= '9') return 1;
	else return 0;
}
int reserved(char str[]) {
	if(strcmp(str, "void") == 0) return 3;
    else if(strcmp(str, "int") == 0) return 4;
    else if(strcmp(str, "float") == 0) return 5;
    else if(strcmp(str, "double") == 0) return 6;
    else if(strcmp(str, "if") == 0) return 7;
    else if(strcmp(str, "else") == 0) return 8;
    else if(strcmp(str, "for") == 0) return 9;
    else if(strcmp(str, "do") == 0) return 10;
    else if(strcmp(str, "while") == 0) return 11;
	else if(strcmp(str, "break") == 0) return 12;
    else if(strcmp(str, "return") == 0) return 13;
    else return 1;
}
int symbol(char ch) {
	if(ch == ';') return 14;
	else if(ch == ',') return 15;
	else if(ch == '(') return 16;
	else if(ch == ')') return 17;
	else if(ch == '{') return 18;
	else if(ch == '}') return 19;
	else if(ch == '[') return 20;
	else if(ch == ']') return 21;
	else if(ch == '%') return 22;
	else if(ch == '?') return 23;
	else if(ch == ':') return 24;
	else if(ch == '\'') return 25;
	else if(ch == '\"') return 26;
	else if(ch == '.') return 27;
	else return 0;
}

int getindex(char ch) {
    switch(ch) {
        case 'i': return 0;
        case '=': return 1;
        case '+': return 2;
        case '-': return 3;
        case '*': return 4;
        case '/': return 5;
        case '(': return 6;
        case ')': return 7;
        case '#': return 8;
        case 'S': return 9;
        case 'E': return 10;
        case 'T': return 11;
        case 'F': return 12;
        case 'V': return 13;
        default: return -1;
    }
}

int use0(int p) { // 判断是否还会用到寄存器rs0内容
    for(int i = p; i <= quadTop; i++) {
        if(strcmp(quad[i].arg1, rs0) == 0 || strcmp(quad[i].arg2, rs0) == 0) {
            return 1;
        }
    }
    return 0;
}
int use1(int p) { // 判断是否还会用到寄存器rs1内容
    for(int i = p; i <= quadTop; i++) {
        if(strcmp(quad[i].arg1, rs1) == 0 || strcmp(quad[i].arg2, rs1) == 0) {
            return 1;
        }
    }
    return 0;
}

void assembly() {
    printf("Assembly Code:\n"); 
    for(int i = 1; i <= quadTop; i++) {
        char opstr[MAX_LEN];
        if(quad[i].op[0] == '=') { // 赋值语句的处理
            if(strcmp(quad[i].arg1, rs0) == 0){
                printf("MOV %s, R0\n", quad[i].result);
            }
            if(strcmp(quad[i].arg1, rs1) == 0) {
                printf("MOV %s, R1\n", quad[i].result);
            }
            continue;
        }
        else if(quad[i].op[0] == '+') { // 获取对应操作码字符串
            strcpy(opstr, "ADD");
        }
        else if(quad[i].op[0] == '-') {
            strcpy(opstr, "SUB");
        }
        else if(quad[i].op[0] == '*') {
            strcpy(opstr, "MUL");
        }
        else if(quad[i].op[0] == '/') {
            strcpy(opstr, "DIV");
        }
        int flag = 0; // flag为0表示两个寄存器都空闲，1表示找到第一个操作数，2表示找到第二个操作数, 3表示两个操作数都找到
        int tag = -1; // tag为0表示值在rs0，1表示值在rs1
        if((strcmp(rs0, quad[i].arg1) == 0 && strcmp(rs1, quad[i].arg2) == 0) || (strcmp(rs0, quad[i].arg2) == 0 && strcmp(rs1, quad[i].arg1) == 0)) {
            flag = 3;
        }
        else if(strcmp(rs0, quad[i].arg1) == 0) {
            flag = 1, tag = 0;
        }
        else if(strcmp(rs1, quad[i].arg1) == 0) {
            flag = 1, tag = 1;
        }
        else if(strcmp(rs0, quad[i].arg2) == 0) {
            flag = 2, tag = 0;
        }
        else if(strcmp(rs1, quad[i].arg2) == 0) {
            flag = 2, tag = 1;
        }
        if(flag == 0) {
            if(rs0[0] == '\0') {
                printf("MOV R0, %s\n", quad[i].arg1);
                printf("%s R0, %s\n", opstr, quad[i].arg2);
                strcpy(rs0, quad[i].result);
                if(use0(i + 1) == 0) {
                    rs0[0] = '\0';
                }
            }
            else if(rs1[0] == '\0') {
                printf("MOV R1, %s\n", quad[i].arg1);
                printf("%s R1, %s\n", opstr, quad[i].arg2);
                strcpy(rs1, quad[i].result);
                if(use1(i + 1) == 0) {
                    rs1[0] = '\0';
                }
            }
            else {
                printf("Assembly failed\n");
                return;
            }
        }
        else if(flag == 1) {
            if(tag == 0) {
                printf("%s R0, %s\n", opstr, quad[i].arg2);
                strcpy(rs0, quad[i].result);
                if(use0(i + 1) == 0) {
                    rs0[0] = '\0';
                }
            }
            else {
                printf("%s R1, %s\n", opstr, quad[i].arg2);
                strcpy(rs1, quad[i].result);
                if(use1(i + 1) == 0) {
                    rs1[0] = '\0';
                }
            }
        }
        else if(flag == 2) {
            if(tag == 0) {
                printf("%s R0, %s\n", opstr, quad[i].arg1);
                strcpy(rs0, quad[i].result);
                if(use0(i + 1) == 0) {
                    rs0[0] = '\0';
                }
            }
            else {
                printf("%s R1, %s\n", opstr, quad[i].arg1);
                strcpy(rs1, quad[i].result);
                if(use1(i + 1) == 0) {
                    rs1[0] = '\0';
                }
            }
        }
        else if(flag == 3) {
            if(use0(i + 1) == 0) {
                printf("%s R0, R1\n", opstr);
                strcpy(rs0, quad[i].result);
            }
            else {
                printf("%s R1, R0\n", opstr);
                strcpy(rs1, quad[i].result);
            }
        }
    }
}

int SLR(char *str, struct stack *stk) { // SLR1分析函数
    quadTop = 0;
    int i = 0;
    int next;
    while(i < strlen(str)) {
        if(stk->top < 0) return 0; // 分析栈不可能为空
        int y; // 列坐标
        if (str[i] >= 'a' && str[i] <= 'z') y = getindex('i'); // 终结符i
        else y = getindex(str[i]);
        if(y == -1 || table[stk->i[stk->top]][y] == 0) { // 表中不存在的状态，分析报错
            return 0;
        }
        if(table[stk->i[stk->top]][y] > 0) { // 移进操作
            next = table[stk->i[stk->top]][y];
            stk->top++;
            stk->s[stk->top] = str[i];
            stk->i[stk->top] = next;
            stk->point[stk->top] = i;
            i++;
        }
        else if(table[stk->i[stk->top]][y] < 0) { // 归约操作
            int tmp = -table[stk->i[stk->top]][y]; // 查GOTO表
            if(tmp == 4 || tmp == 7 || tmp == 9 || tmp == 10) {
                stk->top--; // 要归约1位
            }
            else if(tmp == 2 || tmp == 3 || tmp == 5 || tmp == 6){
                // 生成四元式
                quadTop++;
                if(tmp == 2) strcpy(quad[quadTop].op, "+");
                else if(tmp == 3) strcpy(quad[quadTop].op, "-");
                else if(tmp == 5) strcpy(quad[quadTop].op, "*");
                else strcpy(quad[quadTop].op, "/");
                if(stk->point[stk->top - 2] < 0) sprintf(quad[quadTop].arg1, "t%d", -stk->point[stk->top - 2]);
                else {
                    char arg1[2] = {str[stk->point[stk->top - 2]], '\0'};
                    strcpy(quad[quadTop].arg1, arg1);
                }
                if(stk->point[stk->top] < 0) sprintf(quad[quadTop].arg2, "t%d", -stk->point[stk->top]);
                else {
                    char arg2[2] = {str[stk->point[stk->top]], '\0'};
                    strcpy(quad[quadTop].arg2, arg2);
                }
                sprintf(quad[quadTop].result, "t%d", quadTop);
                stk->top -= 3; // 归约3位
                stk->point[stk->top + 1] = -quadTop; // 记录归约产生的中间变量
            }
            else if(tmp == 8) {
                stk->top -= 3; // 归约3位
                stk->point[stk->top + 1] = stk->point[stk->top + 2]; // 消除括号规约
            }
            else if(tmp == 1){
                quadTop++;
                strcpy(quad[quadTop].op, "=");
                if(stk->point[stk->top] < 0) sprintf(quad[quadTop].arg1, "t%d", abs(stk->point[stk->top]));
                else {
                    char arg1[2] = {str[stk->point[stk->top]], '\0'};
                    strcpy(quad[quadTop].arg1, arg1);
                }
                sprintf(quad[quadTop].arg2, " ");
                char res[2] = {str[stk->point[stk->top - 2]], '\0'};
                strcpy(quad[quadTop].result, res);
                stk->top -= 3; // 归约V=E
            }
            else stk->top -= 3;
            if(tmp == 1) { 
                y = getindex('S');
                next = table[stk->i[stk->top]][y]; // 查ACTION表
                stk->top++;
                stk->s[stk->top] = 'S';
                stk->i[stk->top] = next; // 归约要修改栈顶
            }
            else if(tmp == 2 || tmp ==3 || tmp == 4) {
                y = getindex('E');
                next = table[stk->i[stk->top]][y]; 
                stk->top++;
                stk->s[stk->top] = 'E';
                stk->i[stk->top] = next;
            }
            else if(tmp == 5 || tmp == 6 || tmp == 7) {
                y = getindex('T');
                next = table[stk->i[stk->top]][y];
                stk->top++;
                stk->s[stk->top] = 'T';
                stk->i[stk->top] = next;
            }
            else if(tmp == 8 || tmp == 9) {
                y = getindex('F');
                next = table[stk->i[stk->top]][y];
                stk->top++;
                stk->s[stk->top] = 'F';
                stk->i[stk->top] = next;
            }
            else if(tmp == 10) {
                y = getindex('V');
                next = table[stk->i[stk->top]][y];
                stk->top++;
                stk->s[stk->top] = 'V';
                stk->i[stk->top] = next;
            }
            else if(tmp == 11) {
                return 1; 
            }
        }
    }
    return 0;
}

int main() {
    for(int i = 1; i <= 2; i++){
		char txt1[] = "./test/test";
		char num[8];
		sprintf(num, "%d.txt", i);
		strcat(txt1, num);
		FILE *fp = fopen(txt1, "r");
		int flag = 0;
		char ch = fgetc(fp);	
		while(!feof(fp)) {
			int j = 0;
			if(ch == ' ' || ch == '\t') {
				ch = fgetc(fp);
				continue;
			}
			else if(ch == '\n'){
				ch = fgetc(fp);
				continue;
			}
			else if(english(ch)) {
				do{
					ch = fgetc(fp);
				}while(english(ch)||number(ch));
			}
			else if(number(ch)) {
				do{
					ch = fgetc(fp);
				}while(number(ch));
			}
			else if(symbol(ch) != 0) {
				ch = fgetc(fp);
			}
			else if(ch == '>') {
				ch = fgetc(fp);
				if(ch == '=') {
					ch = fgetc(fp);
				}
				else if(ch == '>') {
					ch = fgetc(fp);
				}
			}
			else if(ch == '<') {
				ch = fgetc(fp);
				if(ch == '=') {
					ch = fgetc(fp);
				}
				else if(ch == '<') {
					ch = fgetc(fp);
				}
			}
			else if(ch == '!') {
				ch = fgetc(fp);
				if(ch == '=') {
					ch = fgetc(fp);
				}
			}
			else if(ch == '=') {
				ch = fgetc(fp);
				if(ch == '=') {
					ch = fgetc(fp);
				}
			}
			else if(ch == '/') {
				ch = fgetc(fp);
				if(ch == '*') {
					do {
						ch = fgetc(fp);
						if(ch == '*') {
							ch = fgetc(fp);
							if(ch == '/') {
								ch = fgetc(fp);
								break;
							}
						}
					}while(1);
				}
				else if(ch == '/') {
					do {
						ch = fgetc(fp);
					}while(ch != '\n');
					ch = fgetc(fp);
				}
				else if(ch == '=') {
					ch = fgetc(fp);
				}
			}
			else if(ch == '&') {
				ch = fgetc(fp);
				if(ch == '&') {
					ch = fgetc(fp);
				}
			}
			else if(ch == '|') {
				ch = fgetc(fp);
				if(ch == '|') {
					ch = fgetc(fp);
				}
			}
			else if(ch == '+') {
				ch = fgetc(fp);
				if(ch == '=') {
					ch = fgetc(fp);
				}
				else if(ch == '+') {
					ch = fgetc(fp);
				}
			}
			else if(ch == '-') {
				ch = fgetc(fp);
				if(ch == '=') {
					ch = fgetc(fp);
				}
				else if(ch == '-') {
					ch = fgetc(fp);
				}
			}
			else if(ch == '*') {
				ch = fgetc(fp);
				if(ch == '=') {
					ch = fgetc(fp);
				}
			}
			else if(ch == '\\') {
				ch = fgetc(fp);
				if(ch == 'n') {
					ch = fgetc(fp);
				}
			}
			else {
				printf("\ntest%d: Undefined Symbol!\n", i); 
				flag = 1;
				break;
			}
		}
        if(flag == 0) printf("\ntest%d: Lexical Legal\n", i);
        else continue;
        fclose(fp);
        FILE *fa = fopen(txt1, "r");
		char input[MAX_LEN] = "";
		fgets(input, MAX_LEN, fa);
        printf("Input scentence: %s\n", input); // input为输入串
        int len = strlen(input);
        input[len] = '#';
		fclose(fa);
        struct stack *stk;
        stk = (struct stack *)malloc(sizeof(struct stack));
		stk->s[0] = '#';
        stk->i[0] = 0;
        stk->point[0] = -1;
        stk->top = 0; //初始化分析栈
        if(!SLR(input, stk)) {
            printf("Gramma illegal\n");
        }
        else {
            //printQuad(); // 打印四元式
            rs0[0] = '\0';
            rs1[0] = '\0';
            assembly(); // 生成汇编代码
        }
	}
    return 0;
}

5.测试运行

tets1：a=(b+c*d)/f+e*g

test2：a=b+(c+d)*/e

程序运行截图

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1379712.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

我开源了一个 Go 学习仓库

我开源了一个 Go 学习仓库

前言 大家好&#xff0c;这里是白泽&#xff0c;我是21年8月接触的 Go 语言&#xff0c;学习 Go 也正好两年半&#xff0c;我决定重启我之前未完成的计划&#xff0c;继续阅读《The Go Programing Language》&#xff0c;一年多前我更新至第五章讲解的时候&#xff0c;工作的忙…
阅读更多...
survey和surveyCV：如何用R语言进行复杂抽样设计、权重计算和10折交叉验证？

survey和surveyCV：如何用R语言进行复杂抽样设计、权重计算和10折交叉验证？

一、引言 在实际调查和研究中&#xff0c;我们往往面临着样本选择的复杂性。复杂抽样设计能够更好地反映真实情况&#xff0c;提高数据的代表性和可靠性。例如&#xff0c;多阶段抽样可以有效地解决大规模调查的问题&#xff0c;整群抽样能够在保证样本的随机性的同时减少资源消…
阅读更多...
20240112-剑来的小文字大道理

20240112-剑来的小文字大道理

– 烽火戏诸侯 《剑来》 与亲近之人不要说气话&#xff0c;不要说反话&#xff0c;不要不说话。 请不要把陌生人的些许善意&#xff0c;视为珍惜的瑰宝&#xff0c;却把身边亲近人的全部付出&#xff0c;当做天经地义的事情&#xff0c;对其视而不见。 读过多少书&#xff0…
阅读更多...
在线项目实习分享：股票价格形态聚类与收益分析

在线项目实习分享：股票价格形态聚类与收益分析

01前置课程 数据挖掘基础数据探索数据预处理数据挖掘算法基础Python数据挖掘编程基础Matplotlib可视化Pyecharts绘图 02师傅带练 行业联动与轮动分析 通过分析申银万国行业交易指数的联动与轮动现象&#xff0c;获得有意义的行业轮动关联规则&#xff0c;并在此基础上设计量…
阅读更多...
智能导诊-医院信息化建设标准

智能导诊-医院信息化建设标准

智能导诊系统主要依赖于自然语言处理和机器学习等技术。患者可以通过语音、文字等方式描述病情&#xff0c;系统通过自然语言处理技术对病情进行语义分析和理解。随后&#xff0c;机器学习算法对患者的症状和病情进行推理&#xff0c;结合已有的疾病知识库&#xff0c;为患者提…
阅读更多...
2024儿童台灯哪个品牌更护眼推荐？五款知名品牌台灯推荐

2024儿童台灯哪个品牌更护眼推荐？五款知名品牌台灯推荐

只要有了娃&#xff0c;家长的吃穿用度可能不会特别讲究&#xff0c;但总想给孩子好的东西&#xff0c;尤其是关系到他们身心健康的&#xff0c;可以说是一掷千金。特别是眼睛视力方面&#xff0c;特别担心会遗传给孩子&#xff0c;自从他上幼儿园&#xff0c;我就一直在物色一…
阅读更多...
学习就要从简单的开始嘛，开始学一个个人博客吧

学习就要从简单的开始嘛，开始学一个个人博客吧

做一个个人博客第一步该怎么做&#xff1f; 好多零基础的同学们不知道怎么迈出第一步。 那么&#xff0c;就找一个现成的模板学一学呗&#xff0c;毕竟我们是高贵的Ctrl c v 工程师。 但是这样也有个问题&#xff0c;那就是&#xff0c;那些模板都&#xff0c;太&#xff01;…
阅读更多...
Fedora 36 正式发布稳定的Linux桌面版本

Fedora 36 正式发布稳定的Linux桌面版本

Fedora 36今天发布&#xff0c;这是最近一段时间以来又一个强大、前沿而又稳定可靠的Linux发行版本&#xff0c;除了这些特点外&#xff0c;Fedora 36还在原先的基础上增加了新的功能和细节打磨。 Fedora 36使用GNOME 42作为其默认的Fedora工作站桌面环境。 OpenSSL 3.0&#x…
阅读更多...
C# winform应用

C# winform应用

C# winform应用 需求&#xff1a;导入Excel文件时需要执行其他操作&#xff0c;实现如果取消导入就不执行其他操作 C#代码实现 private bool DLimport0(string tablename, string datebasename, string buttonname){string xxx "";string Tag "";stri…
阅读更多...
【LeetCode:530. 二叉搜索树的最小绝对差 | 二叉搜索树】

【LeetCode:530. 二叉搜索树的最小绝对差 | 二叉搜索树】

&#x1f680; 算法题 &#x1f680; &#x1f332; 算法刷题专栏 | 面试必备算法 | 面试高频算法 &#x1f340; &#x1f332; 越难的东西,越要努力坚持&#xff0c;因为它具有很高的价值&#xff0c;算法就是这样✨ &#x1f332; 作者简介&#xff1a;硕风和炜&#xff0c;…
阅读更多...
【java八股文】之Redis基础篇

【java八股文】之Redis基础篇

1、Redis有哪几种基本的数据类型 字符串类型&#xff1a;用于存储文章的访问量Hash&#xff1a;用来存储key-value的数据结构&#xff0c;当单个元素比较小和元素数量比较少的时候 &#xff0c;底层是用ziplist存储。通常可以用来存储一些对象之类的List: 底层采用的quicklist …
阅读更多...
yapi无法注册解决，使用yapi pro即可注册,接口文档生成，java,json

yapi无法注册解决，使用yapi pro即可注册,接口文档生成，java,json

1.气屎我了&#xff0c;直接用yapi pro就可以用&#xff0c;害的我弄了半天 2.地址&#xff1a;https://yapi.pro/login 3.yapi pro比较卡顿。开启无痕模式轻松解决该问题&#xff08;手动狗头&#xff09;祝你开启新大陆 yapi pro yapi
阅读更多...
第八讲 单片机驱动彩色液晶屏 控制RA8889软件:显示图片

第八讲 单片机驱动彩色液晶屏 控制RA8889软件:显示图片

单片机驱动TFT彩色液晶屏系列讲座 目录 第一讲 单片机最小系统STM32F103C6T6通过RA8889驱动彩色液晶屏播放视频 第二讲 单片机最小系统STM32F103C6T6控制RA8889驱动彩色液晶屏硬件框架 第三讲 单片机驱动彩色液晶屏 控制RA8889软件:如何初始化 第四讲 单片机驱动彩色液晶屏 控…
阅读更多...
卡尔曼滤波：理论与代码

卡尔曼滤波：理论与代码

卡尔曼滤波&#xff1a;理论与代码 引言 卡尔曼滤波是一种用于估计系统状态的优化技术&#xff0c;特别适用于含有噪声的测量数据和系统动态变化的情况。本文将简单探讨卡尔曼滤波的理论基础、数学公式的推导&#xff0c;并通过Python代码示例演示其在实际应用中的效果。 一…
阅读更多...
20_GC垃圾回收机制

20_GC垃圾回收机制

文章目录 GC如何确定垃圾如何回收垃圾回收垃圾的时机 GC 如何确定垃圾 引用计数算法 给对象添加一个引用计数器&#xff0c;每当一个地方引用它时&#xff0c;计数器加1&#xff0c;每当引用失效时&#xff0c;计数器减少1&#xff0c;当计数器的数值为0时&#xff0c;也就是对…
阅读更多...
python，序列的切片

python，序列的切片

序列的切片就是指从一个序列中取出子序列 语法&#xff1a; 序列[起始下标&#xff1a;结束下标&#xff1a;步长] 步长为1表示一个一个的取元素&#xff0c;步长为2表示每次跳过一个元素的取元素&#xff0c;步长为负数表示反向切片&#xff0c;取元素时取到结束下标&#…
阅读更多...
Python如何免费调用微软Bing翻译API

Python如何免费调用微软Bing翻译API

一、引言 现在免费的机器翻译越来越少了&#xff0c;随着有道翻译开始收费&#xff0c;百度降低用户的免费机器翻译额度(目前只有实名认证过的高级用户才能获得100万字符的免费翻译额度)&#xff0c;而亚马逊、腾讯等机器翻译调用相对比较麻烦&#xff0c;需要下载各种插件包&…
阅读更多...
智能小程序能做什么？

智能小程序能做什么？

一. 自定义Tab页 涂鸦提供了丰富的场景化、个性化的 ToC 智能服务&#xff0c;不仅可以快速低成本的自由搭建出更多智能服务&#xff0c;还为你提供了基于小程序技术方案的可自主可控的自定义开发链路&#xff0c;为拓展更多品牌化、个性化、差异化智能服务提供生态基础。 我…
阅读更多...
Unity之角色控制器

Unity之角色控制器

PS:公司终于给我派任务了&#xff0c;最近几天都没学Unity&#x1f927;。 一、角色控制器的实现方式 目前小编知道的角色控制器实现方式有三种&#xff1a; 应用商店的角色控制系统Unity自己的角色控制器通过物理系统去做角色控制器 本篇介绍的是第二种Unity自己的角色控制…
阅读更多...
【期末不挂科-C++考前速过系列P1】大二C++第1次过程考核（3道简述题＆7道代码题）【解析，注释】

【期末不挂科-C++考前速过系列P1】大二C++第1次过程考核（3道简述题＆7道代码题）【解析，注释】

前言 大家好吖&#xff0c;欢迎来到 YY 滴C复习系列 &#xff0c;热烈欢迎&#xff01; 本章主要内容面向接触过C的老铁 主要内容含&#xff1a; 欢迎订阅 YY滴C专栏&#xff01;更多干货持续更新&#xff01;以下是传送门&#xff01; YY的《C》专栏YY的《C11》专栏YY的《Lin…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023