【读书笔记-《30天自制操作系统》-10】Day11

最新推荐文章于 2024-10-04 20:50:17 发布
最新推荐文章于 2024-10-04 20:50:17 发布
阅读量1.1k 收藏 29
点赞数 37
文章标签： 学习 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ocean1994/article/details/141677905
版权

本篇内容继续围绕显示展开。首先对鼠标显示做了些优化，鼠标箭头在到达画面边缘时能够实现部分隐藏；接下来制作了窗口，实现了窗口显示；最后还在窗口的基础上实现了计数器，显示计数的变化并消除闪烁的问题。
在这里插入图片描述

1. 画面边缘隐藏部分鼠标

首先优化一下鼠标显示，在鼠标箭头移动到画面边缘时，隐藏部分鼠标箭头。主程序中原代码如下：

	if (mx > binfo->scrnx - 16) {
		mx = binfo->scrnx - 16;
	}
	if (my > binfo->scrny - 16) {
		my = binfo->scrny - 16;
	}

修改为如下代码：

	if (mx > binfo->scrnx - 1) {
		mx = binfo->scrnx - 1;
	}
	if (my > binfo->scrny - 1) {
		my = binfo->scrny - 1;
	}

原理也比较简单，显示效果如下：
在这里插入图片描述

可以看出鼠标箭头实现了在画面边缘的部分隐藏，但移出画面之外的部分又产生了其他异常。这里是与图层的刷新有关，只要对于画面之外的部分不进行刷新，就不会产生上面的问题了。修改sheet_refreshsub函数如下：

void sheet_refreshsub(struct SHTCTL *ctl, int vx0, int vy0, int vx1, int vy1)
{
	int h, bx, by, vx, vy, bx0, by0, bx1, by1;
	unsigned char *buf, c, *vram = ctl->vram;
	struct SHEET *sht;
	for (h = 0; h <= ctl->top; h++) {
		sht = ctl->sheets[h];
		buf = sht->buf;
		bx0 = vx0 - sht->vx0;
		by0 = vy0 - sht->vy0;
		bx1 = vx1 - sht->vx0;
		by1 = vy1 - sht->vy0;
		/* 如果超出了范围则进行修正 */
		if (bx0 < 0) { bx0 = 0; }
		if (by0 < 0) { by0 = 0; }
		if (bx1 > sht->bxsize) { bx1 = sht->bxsize; }
		if (by1 > sht->bysize) { by1 = sht->bysize; }
		for (by = by0; by < by1; by++) {
			vy = sht->vy0 + by;
			for (bx = bx0; bx < bx1; bx++) {
				vx = sht->vx0 + bx;
				c = buf[by * sht->bxsize + bx];
				if (c != sht->col_inv) {
					vram[vy * ctl->xsize + vx] = c;
				}
			}
		}
	}
	return;
}

这样修改之后，鼠标在画面边缘的显示就正常多了
在这里插入图片描述
2. 窗口显示

在进入下一步 制作窗口之前，先进行一个小优化。

之前图层控制的数据结构SHTCTL *ctl，在每次进行图层相关的操作时，都需要将ctl指针作为参数传入进去。为了简化，将这一指针加入图层信息描述的结构体中，这样每次操作图层时从图层信息结构体中获取该指针即可，不需要再作为参数单独传入了。

struct SHEET {
	unsigned char *buf;
	int bxsize, bysize, vx0, vy0, col_inv, height, flags;
	struct SHTCTL *ctl; /* 此处增加图层控制指针 */
};

在初始化函数shtctl_init中，需要给此指针赋值：

struct SHTCTL *shtctl_init(struct MEMMAN *memman, unsigned char *vram, int xsize, int ysize)
{
	struct SHTCTL *ctl;
	int i;
	ctl = (struct SHTCTL *) memman_alloc_4k(memman, sizeof (struct SHTCTL));
	if (ctl == 0) {
		goto err;
	}
	ctl->vram = vram;
	ctl->xsize = xsize;
	ctl->ysize = ysize;
	ctl->top = -1;
	for (i = 0; i < MAX_SHEETS; i++) {
		ctl->sheets0[i].flags = 0; 
		ctl->sheets0[i].ctl = ctl; 
	}
err:
	return ctl;
}

之前所有涉及到ctl指针的部分也都要一并修改。

接下来就可以制作窗口了。其实制作窗口也是准备一个图层，并在上面绘制图案，这里作者写了一个函数make_window8

void make_window8(unsigned char *buf, int xsize, int ysize, char *title)
{
	static char closebtn[14][16] = {
		"OOOOOOOOOOOOOOO@",
		"OQQQQQQQQQQQQQ$@",
		"OQQQQQQQQQQQQQ$@",
		"OQQQ@@QQQQ@@QQ$@",
		"OQQQQ@@QQ@@QQQ$@",
		"OQQQQQ@@@@QQQQ$@",
		"OQQQQQQ@@QQQQQ$@",
		"OQQQQQ@@@@QQQQ$@",
		"OQQQQ@@QQ@@QQQ$@",
		"OQQQ@@QQQQ@@QQ$@",
		"OQQQQQQQQQQQQQ$@",
		"OQQQQQQQQQQQQQ$@",
		"O$$$$$$$$$$$$$$@",
		"@@@@@@@@@@@@@@@@"
	};
	int x, y;
	char c;
	boxfill8(buf, xsize, COL8_C6C6C6, 0,         0,         xsize - 1, 0        );
	boxfill8(buf, xsize, COL8_FFFFFF, 1,         1,         xsize - 2, 1        );
	boxfill8(buf, xsize, COL8_C6C6C6, 0,         0,         0,         ysize - 1);
	boxfill8(buf, xsize, COL8_FFFFFF, 1,         1,         1,         ysize - 2);
	boxfill8(buf, xsize, COL8_848484, xsize - 2, 1,         xsize - 2, ysize - 2);
	boxfill8(buf, xsize, COL8_000000, xsize - 1, 0,         xsize - 1, ysize - 1);
	boxfill8(buf, xsize, COL8_C6C6C6, 2,         2,         xsize - 3, ysize - 3);
	boxfill8(buf, xsize, COL8_000084, 3,         3,         xsize - 4, 20       );
	boxfill8(buf, xsize, COL8_848484, 1,         ysize - 2, xsize - 2, ysize - 2);
	boxfill8(buf, xsize, COL8_000000, 0,         ysize - 1, xsize - 1, ysize - 1);
	putfonts8_asc(buf, xsize, 24, 4, COL8_FFFFFF, title);
	for (y = 0; y < 14; y++) {
		for (x = 0; x < 16; x++) {
			c = closebtn[y][x];
			if (c == '@') {
				c = COL8_000000;
			} else if (c == '$') {
				c = COL8_848484;
			} else if (c == 'Q') {
				c = COL8_C6C6C6;
			} else {
				c = COL8_FFFFFF;
			}
			buf[(5 + y) * xsize + (xsize - 21 + x)] = c;
		}
	}
	return;
}

虽然程序代码看起来不少，其实与之前描绘鼠标的原理一样，只是在适当的位置描绘出图案。这样在主函数中也需要增加一些内容：

/* 新增了窗口的图层管理指针与buf*/
	struct SHEET *sht_back, *sht_mouse, *sht_win;
	unsigned char *buf_back, buf_mouse[256], *buf_win;

/* 为窗口分配图层和内存*/
	sht_win   = sheet_alloc(shtctl);
	buf_win   = (unsigned char *) memman_alloc_4k(memman, 160 * 68);

	sheet_setbuf(sht_win, buf_win, 160, 68, -1);
	init_screen8(buf_back, binfo->scrnx, binfo->scrny);
	init_mouse_cursor8(buf_mouse, 99);
	make_window8(buf_win, 160, 68, "window");
	putfonts8_asc(buf_win, 160, 24, 28, COL8_000000, "Welcome to");
	putfonts8_asc(buf_win, 160, 24, 44, COL8_000000, "  Haribote-OS!");

	sheet_slide(sht_win, 80, 72);
	sheet_updown(sht_back,  0);
	sheet_updown(sht_win,   1);
	sheet_updown(sht_mouse, 2);

从程序中可以看出，将窗口图层的高度设置为1，处于背景图层与鼠标图层之间，这样鼠标就可以位于窗口图层之上。运行之后的显示结果如下
在这里插入图片描述窗口的显示完成了，下面更进一步，由CPU进行计数，并将数字在窗口中显示出来：

void HariMain(void)
{
	struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;
	char s[40], keybuf[32], mousebuf[128];
	int mx, my, i;
	unsigned int memtotal, count = 0;
	struct MOUSE_DEC mdec;
	struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
	struct SHTCTL *shtctl;
	struct SHEET *sht_back, *sht_mouse, *sht_win;
	unsigned char *buf_back, buf_mouse[256], *buf_win;

	init_gdtidt();
	init_pic();
	io_sti();
	fifo8_init(&keyfifo, 32, keybuf);
	fifo8_init(&mousefifo, 128, mousebuf);
	io_out8(PIC0_IMR, 0xf9); 
	io_out8(PIC1_IMR, 0xef); 

	init_keyboard();
	enable_mouse(&mdec);
	memtotal = memtest(0x00400000, 0xbfffffff);
	memman_init(memman);
	memman_free(memman, 0x00001000, 0x0009e000); /* 0x00001000 - 0x0009efff */
	memman_free(memman, 0x00400000, memtotal - 0x00400000);

	init_palette();
	shtctl = shtctl_init(memman, binfo->vram, binfo->scrnx, binfo->scrny);
	sht_back  = sheet_alloc(shtctl);
	sht_mouse = sheet_alloc(shtctl);
	sht_win   = sheet_alloc(shtctl);
	buf_back  = (unsigned char *) memman_alloc_4k(memman, binfo->scrnx * binfo->scrny);
	buf_win   = (unsigned char *) memman_alloc_4k(memman, 160 * 52);
	sheet_setbuf(sht_back, buf_back, binfo->scrnx, binfo->scrny, -1); 
	sheet_setbuf(sht_mouse, buf_mouse, 16, 16, 99);
	sheet_setbuf(sht_win, buf_win, 160, 52, -1); 
	init_screen8(buf_back, binfo->scrnx, binfo->scrny);
	init_mouse_cursor8(buf_mouse, 99);
	make_window8(buf_win, 160, 52, "counter");/* 增加计数器 */
	sheet_slide(sht_back, 0, 0);
	mx = (binfo->scrnx - 16) / 2; 
	my = (binfo->scrny - 28 - 16) / 2;
	sheet_slide(sht_mouse, mx, my);
	sheet_slide(sht_win, 80, 72);
	sheet_updown(sht_back,  0);
	sheet_updown(sht_win,   1);
	sheet_updown(sht_mouse, 2);
	sprintf(s, "(%3d, %3d)", mx, my);
	putfonts8_asc(buf_back, binfo->scrnx, 0, 0, COL8_FFFFFF, s);
	sprintf(s, "memory %dMB   free : %dKB",
			memtotal / (1024 * 1024), memman_total(memman) / 1024);
	putfonts8_asc(buf_back, binfo->scrnx, 0, 32, COL8_FFFFFF, s);
	sheet_refresh(sht_back, 0, 0, binfo->scrnx, 48);

	for (;;) {
		count++; /* 计数 */
		sprintf(s, "%010d", count);
		boxfill8(buf_win, 160, COL8_C6C6C6, 40, 28, 119, 43);
		putfonts8_asc(buf_win, 160, 40, 28, COL8_000000, s);
		sheet_refresh(sht_win, 40, 28, 120, 44);

		io_cli();
		if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) == 0) {
			io_sti();
		} else {
			if (fifo8_status(&keyfifo) != 0) {
				i = fifo8_get(&keyfifo);
				io_sti();
				sprintf(s, "%02X", i);
				boxfill8(buf_back, binfo->scrnx, COL8_008484,  0, 16, 15, 31);
				putfonts8_asc(buf_back, binfo->scrnx, 0, 16, COL8_FFFFFF, s);
				sheet_refresh(sht_back, 0, 16, 16, 32);
			} else if (fifo8_status(&mousefifo) != 0) {
				i = fifo8_get(&mousefifo);
				io_sti();
				if (mouse_decode(&mdec, i) != 0) {
					sprintf(s, "[lcr %4d %4d]", mdec.x, mdec.y);
					if ((mdec.btn & 0x01) != 0) {
						s[1] = 'L';
					}
					if ((mdec.btn & 0x02) != 0) {
						s[3] = 'R';
					}
					if ((mdec.btn & 0x04) != 0) {
						s[2] = 'C';
					}
					boxfill8(buf_back, binfo->scrnx, COL8_008484, 32, 16, 32 + 15 * 8 - 1, 31);
					putfonts8_asc(buf_back, binfo->scrnx, 32, 16, COL8_FFFFFF, s);
					sheet_refresh(sht_back, 32, 16, 32 + 15 * 8, 32);
					mx += mdec.x;
					my += mdec.y;
					if (mx < 0) {
						mx = 0;
					}
					if (my < 0) {
						my = 0;
					}
					if (mx > binfo->scrnx - 1) {
						mx = binfo->scrnx - 1;
					}
					if (my > binfo->scrny - 1) {
						my = binfo->scrny - 1;
					}
					sprintf(s, "(%3d, %3d)", mx, my);
					boxfill8(buf_back, binfo->scrnx, COL8_008484, 0, 0, 79, 15); 
					putfonts8_asc(buf_back, binfo->scrnx, 0, 0, COL8_FFFFFF, s); 
					sheet_refresh(sht_back, 0, 0, 80, 16);
					sheet_slide(sht_mouse, mx, my);
				}
			}
		}
	}
}

在这里插入图片描述
显示的结果就是窗口中的数字在不断增加。但是数字显示的地方闪烁很严重，能看到背景色在一闪一闪。这是因为在刷新图层的时候，总是先刷新背景图层，再刷新窗口图层，因为数字的更新，刷新一直在进行，就会导致背景色一直在闪烁。

解决这一问题的方法很简单，如果只有窗口变化，其实不用刷新背景图层。因此refresh只对对象图层及其上面的图层进行刷新就可以了。实际修改时，sheet_refresh函数只刷新指定的图层及其上面的图层；而sheet_slide函数中，图层的移动有时会导致下面的图层露出，因此需要从最下面的图层开始刷新，而对于移动后的位置，也只需要刷新目标图层与上面的图层即可。

进行这些修改之后，计数器的数字显示闪烁问题解决了，但将鼠标放在计数器上面，又会发现鼠标的闪烁问题。这里需要另外的解决方法了。

struct SHTCTL {
	unsigned char *vram, *map;
	int xsize, ysize, top;
	struct SHEET *sheets[MAX_SHEETS];
	struct SHEET sheets0[MAX_SHEETS];
};

struct SHTCTL *shtctl_init(struct MEMMAN *memman, unsigned char *vram, int xsize, int ysize)
{
	struct SHTCTL *ctl;
	int i;
	ctl = (struct SHTCTL *) memman_alloc_4k(memman, sizeof (struct SHTCTL));
	if (ctl == 0) {
		goto err;
	}
	ctl->map = (unsigned char *) memman_alloc_4k(memman, xsize * ysize);
	if (ctl->map == 0) {
		memman_free_4k(memman, (int) ctl, sizeof (struct SHTCTL));
		goto err;
	}
	ctl->vram = vram;
	ctl->xsize = xsize;
	ctl->ysize = ysize;
	ctl->top = -1; 
	for (i = 0; i < MAX_SHEETS; i++) {
		ctl->sheets0[i].flags = 0;
		ctl->sheets0[i].ctl = ctl;
	}
err:
	return ctl;
}

这里开辟了一块与VRAM同样大小的内存，命名为map，用来表示画面上的点是哪个图层的像素，如图所示：
在这里插入图片描述
多个图层重叠的情况下，根据这个map进行刷新，就可以清楚地确定图层互相之间的覆盖关系了。

使用map首先要向map中写入图层的号码

void sheet_refreshmap(struct SHTCTL *ctl, int vx0, int vy0, int vx1, int vy1, int h0)
{
	int h, bx, by, vx, vy, bx0, by0, bx1, by1;
	unsigned char *buf, sid, *map = ctl->map;
	struct SHEET *sht;
	if (vx0 < 0) { vx0 = 0; }
	if (vy0 < 0) { vy0 = 0; }
	if (vx1 > ctl->xsize) { vx1 = ctl->xsize; }
	if (vy1 > ctl->ysize) { vy1 = ctl->ysize; }
	for (h = h0; h <= ctl->top; h++) {
		sht = ctl->sheets[h];
		sid = sht - ctl->sheets0; /* 将进行了减法计算的地址作为图层号码使用*/
		buf = sht->buf;
		bx0 = vx0 - sht->vx0;
		by0 = vy0 - sht->vy0;
		bx1 = vx1 - sht->vx0;
		by1 = vy1 - sht->vy0;
		if (bx0 < 0) { bx0 = 0; }
		if (by0 < 0) { by0 = 0; }
		if (bx1 > sht->bxsize) { bx1 = sht->bxsize; }
		if (by1 > sht->bysize) { by1 = sht->bysize; }
		for (by = by0; by < by1; by++) {
			vy = sht->vy0 + by;
			for (bx = bx0; bx < bx1; bx++) {
				vx = sht->vx0 + bx;
				if (buf[by * sht->bxsize + bx] != sht->col_inv) {
					map[vy * ctl->xsize + vx] = sid;
				}
			}
		}
	}
	return;
}

这个函数的原理其实与refreshsub函数基本一样，只不过后者是写入色号，而这里是把图层号码sid写入到map。

同样改写了sheet_refreshsub函数，使其可以使用map:

void sheet_refreshsub(struct SHTCTL *ctl, int vx0, int vy0, int vx1, int vy1, int h0, int h1)
{
	int h, bx, by, vx, vy, bx0, by0, bx1, by1;
	unsigned char *buf, *vram = ctl->vram, *map = ctl->map, sid;
	struct SHEET *sht;
	if (vx0 < 0) { vx0 = 0; }
	if (vy0 < 0) { vy0 = 0; }
	if (vx1 > ctl->xsize) { vx1 = ctl->xsize; }
	if (vy1 > ctl->ysize) { vy1 = ctl->ysize; }
	for (h = h0; h <= h1; h++) {
		sht = ctl->sheets[h];
		buf = sht->buf;
		sid = sht - ctl->sheets0;
		bx0 = vx0 - sht->vx0;
		by0 = vy0 - sht->vy0;
		bx1 = vx1 - sht->vx0;
		by1 = vy1 - sht->vy0;
		if (bx0 < 0) { bx0 = 0; }
		if (by0 < 0) { by0 = 0; }
		if (bx1 > sht->bxsize) { bx1 = sht->bxsize; }
		if (by1 > sht->bysize) { by1 = sht->bysize; }
		for (by = by0; by < by1; by++) {
			vy = sht->vy0 + by;
			for (bx = bx0; bx < bx1; bx++) {
				vx = sht->vx0 + bx;
				if (map[vy * ctl->xsize + vx] == sid) {
					vram[vy * ctl->xsize + vx] = buf[by * sht->bxsize + bx];
				}
			}
		}
	}
	return;
}

根据map中记录的图层编号，分别进行刷新。由于参照map进行刷新，不需要再从下到上刷新每一个图层，因此这个函数增加了传参h1，用于和h0一起指定刷新图层的范围。

对于sheet_slide做如下修改：

void sheet_slide(struct SHEET *sht, int vx0, int vy0)
{
	struct SHTCTL *ctl = sht->ctl;
	int old_vx0 = sht->vx0, old_vy0 = sht->vy0;
	sht->vx0 = vx0;
	sht->vy0 = vy0;
	if (sht->height >= 0) { 
		sheet_refreshmap(ctl, old_vx0, old_vy0, old_vx0 + sht->bxsize, old_vy0 + sht->bysize, 0);
		sheet_refreshmap(ctl, vx0, vy0, vx0 + sht->bxsize, vy0 + sht->bysize, sht->height);
		sheet_refreshsub(ctl, old_vx0, old_vy0, old_vx0 + sht->bxsize, old_vy0 + sht->bysize, 0, sht->height - 1);
		sheet_refreshsub(ctl, vx0, vy0, vx0 + sht->bxsize, vy0 + sht->bysize, sht->height, sht->height);
	}
	return;
}

在sheet_slide函数中，首先重写map，分别对应移动前后的图层。然后调用sheet_refrehsub函数。对于原位置，需要对上层图层移动后的下层图层重新绘制；而在新位置，只需要绘制移动过去的图层即可。

简单理解，其实就是通过map把叠加后的显示结果存储起来，最终绘制的时候只需要绘制一张画面，而不是从下向上描绘多个图层来最终实现叠加效果，这样避免了从下而上的刷新，就消除了闪烁。相比原来实现叠加的方法也更进了一步。

本篇内容其实修改增加的代码不多，主要还是在前文的基础上进行，但是方法概念需要好好理解。显示问题暂告一段落，下一篇开始定时器的相关内容，敬请期待。

洛寒瑜
关注
30天自制操作系统——自写设计
君陌的博客
12-23 7971
写在前面：这是我在学习了一个学期的《30天自制操作系统》之后，用了差不多一个周的时间，所写出来的一个纸娃娃操作系统，有一个小的开机动画，可以输入密码，然后有一个小的画图程序。现在把他写出来，只是为了记录这一个学期的学习经历吧，至少证明自己学有所成，所有所获。 一、实验环境 硬件环境：计算机，无特殊配置要求 软件环境：QEMU虚拟机、批处理文件、相关编译工具等 语言环境：C语言、汇编语言 二、功能介...
30天自制操作系统 综合设计
人间烟火的博客
02-07 688
综合设计开机动画密码时钟的实现双击画图小程序 开机动画 开机动画是一帧一帧组成的，我画了37-15+1=23帧的动画，特别是发散的帧比较难画 通过每一帧设置比较短的时间间隔，可以得到动态的效果 这部分的工作量比较大 动画的原理就是一帧一帧的播放，我模仿的是一个安卓的开机动画的一部分。 密码 开机动画结束后会出现密码的界面，密码的实现方式是定义一个数组，对输入的字符与密码的字符进行一位一位的对比，如果相同，则flagmima[]数组对应的那一位就赋值为1，最后的enter键也是一位，也可
【读书笔记-《30天自制操作系统》-22】Day23
Ocean1994的博客
09-19 1395
本篇内容比较简单，集中于显示问题。首先编写了应用程序使用的api_malloc，然后实现了在窗口中画点与画线的API与应用程序。有了窗口显示，还要实现关闭窗口的功能，于是在键盘输入API的基础上实现了按下按键关闭窗口。最后发现用上文的强制结束按键结束应用程序，程序的窗口还没有关闭，又增加了强制结束程序时关闭窗口的功能。
【读书笔记-《30天自制操作系统》-23】Day24
Ocean1994的博客
09-20 1413
本篇内容依然比较简单，主要是优化窗口功能以及开发定时器应用程序。首先是优化窗口的切换功能，实现通过键盘和鼠标切换窗口，然后是实现通过鼠标关闭窗口。接着实现不同窗口输入状态的切换，最后是实现定时器的API与应用程序。
【读书笔记-《30天自制操作系统》-13】Day14
Ocean1994的博客
09-01 2411
相比前几篇的内容，本篇不仅内容更为简单，而且与显示相关，更为有趣。首先通过调用VBE的显示模式提高显示画面的分辨率，然后分别实现按下键盘按键显示对应的字符，以及通过鼠标移动窗口。因为是以前面讲过的很多内容为基础，程序代码很简单，而且能切实看到成果，也更有趣。
【读书笔记-《30天自制操作系统》-24】Day25
Ocean1994的博客
09-23 957
本篇内容也比较简单。首先开发了蜂鸣器的API，然后增加更多的颜色显示。为了同时运行两个应用程序，又增加了一个命令行窗口。
【读书笔记-《30天自制操作系统》-7】Day8
Ocean1994的博客
08-22 800
本篇讲解实现鼠标移动的最后工作，并且讲解前面没有详细说明的进入32位模式的过程。
【读书笔记-《30天自制操作系统》-19】Day20
Ocean1994的博客
09-11 1143
本篇的内容围绕系统调用展开。为了让应用程序能够调用操作系统功能，引入了系统调用以及API的概念。首先实现了显示单个字符的API，让应用程序通过传递地址的方式进行调用；接下来又改进为通过中断的方式进行调用。在此基础上继续实现了显示字符串的API。
【读书笔记-《30天自制操作系统》-3】Day4
Ocean1994的博客
08-16 1021
本篇主要实现了画面显示部分，同时从汇编语言的角度引入了指针的概念。
《30天自制操作系统》学习笔记 day22-day30
qq_41956860的博客
10-18 823
文章目录DAY 221. 进度记录2. 学习与总结（1）应用程序触发异常的情况（2）栈异常（3）hrb文件格式（4）显示窗口、窗口中输入字符、图形API DAY 22 1. 进度记录 增加强制结束应用程序 Shift+F1 C语言显示字符串， 显示窗口 窗口中描绘字符和方块 2. 学习与总结 （1）应用程序触发异常的情况 执行IN、OUT 执行CLI、STI、HLT等指令 CALL、JMP ...
30天自制操作系统学习笔记----day_five
lzh
10-31 881
一、实验主要内容 1.接受启动信息： 关键代码：      重点内容： （1）通过指针来获得显示画面模式，这样可以避免当画面模式改变时系统无法正常运行的问题。 2.试用结构体： 关键代码： 重点内容： 如何理解结构体：struct后面是结构体的名字同时也是这个结构体的首地址，结构体可以理解为一个文件柜，各个变量可以看做接口，需要使用的时候接上这个接口即可，通过结构体对...
《30天自制操作系统》学习笔记_day03
zhangkai9895的博客
03-31 421
前言：第三天的难度还是蛮大的，看了一上午理解了大概，还是好好记录，捋顺一下。 1.实现Ipl的程序装载 首先实现用ipl指示将程序（软盘内容，操作系统）装载到内存特定位置 在03_day的harrib00a中的ipl.nas添加内容的部分 可以看到用到了 BIOS INT 0x13中断，0x13号中断主要用来磁盘的读写，AH=0x02说明用来读盘。 具体软盘的结构可以查询学习。 AH=处理对象的...
30天自制操作系统学习笔记----day_two
lzh
10-31 830
一、实验主要内容 介绍文本编辑器： 重点总结：下载并安装文本编辑器TearPad，默认语言是日文，若想汉化安装汉化包即可，但推荐使用Notepad++，在软件安装时选择简体中文即可。 继续开发： 重点总结：各种指令及其作用 ORG:这个指令告诉nask，当程序开始执行的时候，把汇编文件中的机器语言装载到内存的某个地址中。需要注意的时候，当有ORG指令的时候，$代表的意思是立即数，亦即将要读入...
《30天自制操作系统》学习笔记_day01
zhangkai9895的博客
03-30 283
《30天自制操作系统》学习笔记_day01 1.二进制编辑器查看操作系统源代码并编写 博主未采用书中推荐二进制编辑器，而是使用Notepad++和HexEditor插件。 参考：新版Notepad++加十六进制查看的插件HexEditor 000000：HELLOIPL启动区的名称可以是任意的字符串（8字节） 启动区： 软盘的第一个扇区为启动区，计算机读取软盘512个字节为一个扇区单位。软盘大小...
深度学习每周学习总结J1（ResNet-50算法实战与解析 - 鸟类识别）
最新发布
qq_33489955的博客
10-04 645
数据导入及处理部分：本次数据导入没有使用torchvision自带的数据集，需要将原始数据进行处理包括数据导入，查看数据分类情况，定义transforms，进行数据类型转换等操作。划分数据集：划定训练集测试集后，再使用torch.utils.data中的DataLoader()分别加载上一步处理好的训练及测试数据，查看批处理维度.模型构建部分：resnet-50。
Go基础学习08-并发安全型类型-通道（chan）深入研究
FLJS_T的博客
09-28 888
在前面学习中了解到对于单值变量，如：int、string；多值变量，如：map存在多协程对资源竞争的并发问题，为了解决并发性通常需要引入sync.Mutex解决。>对于通道的基本声明方式有三种：声明并初始化带缓冲的通道（ch1）；声明并初始化一个不带缓冲的通道（ch2）；仅仅声明一个通道（ch3） >什么是通道：==一个通道相当于一个先进先出（FIFO）的队列。也就是说，通道中的各个元素值都是严格地按照发送的顺序排列的，先被发送通道的元素值一定会先被接收。Select和for循环实现对channel的多次选
10.2学习
2401_87363162的博客
10-02 1103
​ Spring AOP就是基于动态代理的，如果要代理的对象，实现了某个接⼝，那么Spring AOP会使⽤JDKProxy，去创建代理对象，⽽对于没有实现接⼝的对象，就⽆法使⽤ JDK Proxy 去进⾏代理了，这时候Spring AOP会使⽤基于asm框架字节流的Cglib动态代理 ，这时候Spring AOP会使⽤ Cglib ⽣成⼀个被代理对象的⼦类来作为代理。每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。
操作系统笔记：信号量与读者-写者问题解析
"这篇资源是关于自考课程(02327)操作系统的个人学习笔记，涵盖了操作系统的基本概念和核心机制。" 操作系统是计算机系统中的核心软件，它管理并控制计算机硬件和软件资源，为用户提供服务，实现任务调度、内存管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值