codersgl's blog

Operating system

Fri, 13 Mar 2026 20:51:24 +0800

The structure of operating system

Hierarchy

Advantage
1. Convenient for the OS to debug and valid, simplify the design and implementation of the system.
2. Easy to extend and maintain.
Disadvantage
1. Low efficiency
2. Difficult to define the layer reasonably.

Modularization

Modularization means splitting the operating system into some independent modules by functions.

Data structure and algorithms

Thu, 12 Mar 2026 22:27:38 +0800

Base Concept of Data Structure

Data Element

Data element is the basic unit of data, every data element has some Data Items, which are the minimal units that consist of Data element

Data Structure

Data structure is a set of data elements which have one or more special relationship with each other.

The logical structure of data

Linear
- Normal linear list
- Restricted linear list
  - Stack and Queue
  - String
- Extended linear list
  - Array
Nonlinear
- Set
- Tree
  - Normal tree
  - Binary tree
- Graph
  - Directed graph
  - Undirected graph

The storage structure of data

Ordered storage
Linked storage
Index storage
Hash storage

The operation of data

Algorithm

Algorithm is a description of solving steps for special problems. It has five features:

Finiteness
Certainty
Feasibility
Input
Output

The metric of Algorithm efficiency

Time Complexity
Spatial Complexity

Linear list

Consecutive elements of the same type are limited in number, and every middle element in the sequence has exactly one element immediately before it and one element immediately after it.

Base operations of linear list

InitList(&L): Initialize a list.
Length(L): Get the length of a list, the number of list elements.
LocateElem(L, e): Find by value.
GetElem(L, i): Find by index.
ListInsert(&L, i, e): Insert specified value e at the i-th element of list L.
ListDelete(&L, i, &e): Delete the i-th element of list L, and return its value to e.
PrintList(L): Print all elements in list L.
Empty(L): Returns ture if the list L is empty, otherwise returns false.
DestroyList(&L): Free the memory of list L.

sequence list

Place the elements by using a group of consecutive memory address.

features:
- Easy to access and modify the element of sequence list.
- Difficult to add and remove the element of sequence list.

In Python, Implement a sequence list by using the builtin type list, For example:

1
2
3
4
5
6
7



a = list() # Create a empty list.
a.append(1) # Add a new element.
a.remove(1) # Remove a element.

b = [1, 2, 3] # Easier create a list.
c = b[0] # Get the first element of the list b.

But note to it doesn’t make sure every element own same type in Python.

Linked list

Place the elements by using some random memory address, but every element has data and pointer that point to the address of next element.

features:
- Easy to add and remove the elements of link list.
- Difficult to access and modify the elements of link list.

In Python, you need to define a node class to implement the function of link list, like that:

1
2
3
4
5
6
7
8
9


class Node:
 def __init__(self, val: Any):
 self.val = val
 self.next = None

# Create a head node.
head = Node(1) # 1 -> None
head.next = Node(2) # 1 -> 2 -> None
head.next.next = Node(3) # 1 -> 2 -> 3 -> None

Doubly Linked List

Every node includes two points: one pointer points to the previous node and another points to next node.

Circular Linked List

The pointer of last node points to the first node, making a circular, it could be single direction or double direction.

Insert Node

Head Insert: The pointer of new node points to head node, head pointer points to new node.
Rear Insert: Traverse to find the last node, making it point to new node.
Middle Insert: Find the target node, new node points to its next node, target node points to new node.

Remove Node

Remove Head Node: Head pointer points to the next node of head node, making it new head node, original head node points to None.
Remove Rear Node: Find the previous node of rear node, making it point to None.
Remove Middle Node: Find the previous node of target node, making it point to the next node of target node, then making the target node point to None.

VSCode中配置C/C++运行和调试环境

Tue, 06 Jan 2026 17:52:23 +0800

首先配置C/C++的插件，然后执行Ctrl+Shift+B执行生成任务，注意此时焦点一定要将待执行的文件上，否则会报错。

修改生成的task.json

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


{
 "tasks": [
 {
 "type": "cppbuild",
 "label": "C/C++: gcc 生成活动文件",
 "command": "/usr/bin/gcc",
 "args": [
 "-fdiagnostics-color=always",
 "-g",
 "${file}",
 "-o",
 "${workspaceFolder}/build/${fileBasenameNoExtension}"
 ],
 "options": {
 "cwd": "${workspaceFolder}"
 },
 "problemMatcher": ["$gcc"],
 "group": {
 "kind": "build",
 "isDefault": true
 },
 "detail": "调试器生成的任务。",
 }
 ],
 "version": "2.0.0"
}

修改两处：

“args’:"${filenamedir}/${fileBasenameNoExtension}"修改为"${workspaceFolder}/bulid/${fileBasenameNoExtension}"，让生成的可执行文件存放在固定文件夹下，方便整理
“cwd”: "${filenamedir}修改为${workspaceFolder}，将命令行目录改为工作区目录

然后，生成lunch.json文件，下面是我的配置模板，该模板可复用，但我现在使用的是WSL环境，不用的操作系统细节可能有些不同。主要的修改点在"program": "${workspaceRoot}/build/${fileBasenameNoExtension}"和"miDebuggerPath": "/usr/bin/gdb"，前者的意思是调试工作目录下的build文件夹下的可执行文件，后者是你的GDB路径，在Linux下执行which gdb即可得到，如果没有出现路径，安装GDB即可。

这里补充一下，修改"cwd": "${workspaceFolder}/build"与task.json同步,

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


{
 // 使用 IntelliSense 了解相关属性。
 // 悬停以查看现有属性的描述。
 // 欲了解更多信息，请访问: https://go.microsoft.com/fwlink/?linkid=830387
 "version": "0.2.0",
 "configurations": [
 {
 "name": "(gdb) 启动",
 "type": "cppdbg",
 "request": "launch",
 "program": "${workspaceRoot}/build/${fileBasenameNoExtension}",
 "args": [],
 "stopAtEntry": false,
 "cwd": "${workspaceFolder}/build",
 "environment": [],
 "externalConsole": false,
 "MIMode": "gdb",
 "miDebuggerPath": "/usr/bin/gdb",
 "setupCommands": [
 {
 "description": "为 gdb 启用整齐打印",
 "text": "-enable-pretty-printing",
 "ignoreFailures": true
 },
 {
 "description": "将反汇编风格设置为 Intel",
 "text": "-gdb-set disassembly-flavor intel",
 "ignoreFailures": true
 }
 ]
 }
 ]
}

值得一提的是，现在的配置文件是单文件配置，对于一个大型项目肯定包含多个C/C++文件，当前配置可能不适用，我还在探索中，有机会后面在补充。

好了，这就是这篇博客的全部内容，简单讲解了一下VSCode中配置C/C++运行和调试环境的核心内容，当然还有一些前置条件没提，比如安装C/C++插件，配置该插件，这些请读者自行探索。

一个艰难的决定

Tue, 06 Jan 2026 00:07:21 +0800

从今天起，我打算放弃折腾neovim了。当然并不是说neovim不好，相反它很好，无需鼠标，仅用键盘作为输入的唯一操作方式，这是非一般的体验。我也一直希望能把它作为我的主力编辑器使用，唯一的缺点是配置太繁琐了，不管是LSP，还是Lazygit都折腾的我头大。除此之外，浩如烟海的快捷键实在是太难记了，每种插件都有一堆快捷键，每个插件都有自定义的配置，感觉以我现在的水平还不足以驾驭它，因此先将其搁置一边，专心敲代码趴。但Vim模式还是很香的，我现在用Vscode作为主力编辑器，同时搭配Vim插件，说实话体验还不赖，就是不能像neovim一样用键盘掌控一切，其实理论上可行，但还需要学习一些Vscode的快捷键，有点烦，有点乱。

总之，事情就是这样，我暂时放弃折腾neovim，专心完成手上一些重要的工作，顺便水一篇博客。顺带一提，写这篇博客时还顺便学了下gj和gk可以实现视觉折行内的上下切换，蒸蚌！！!。

BTW，折腾neovim真好玩！！！