2026-06-21T11:43:30.045Z
  
  
    
      FRiver
    
    
    
    
    
      Openclaw 的目标是解放全人类
初识
在每天的学习生活中，总要会使用ai，豆老师，d老师，元老师，千千万万的大模型在当下社会十分火热。加上前刚不久，在兴趣小组内作了简单的知识分享，内容也与ai模型殊途同归。在此刻从openclaw入手，或许再好不过了。
深入
openclaw算是个产品，而本质蕴含的ai思想，咨询豆老师之后，是有原本的学名的，即harness engineering。即通过一个agent，接入模型之后，实现真正的解放生产力。作为cs自学指南的资深粉丝，也希望从其中寻找到关于HE的蛛丝马迹。未果，但并非后遂无问津者，b站前几天刚有一个很好的教学视频，值得作初步的了解。之后通过微信公众号，了解到程序员鱼皮也在最近发布了一篇文章，也拿来饱读一番。
动手
了解了基本的内容，就开始着手操作一番了。安装openclaw以及配置模型的流程并不算难，其实问ai就行，配置虚拟环境，安装agent，配置api，最后部署模型。
而真正让我吃惊的，是openclaw他真的干活了!  
首先是我第一次安装openclaw，做一个简单的尝试，我给了他一些简单的token,让他显示一下北京近7天的天气状况，之后通过chrome浏览器打开。果不其然，he did it!
最近在逛实验室网站的时候，发现了一个有趣的项目,c语言哈希表，正好作为c语言复习，了解一下哈希表，一举两得，一石二鸟，一箭双雕……打开发现，其实是一个很老的经典项目了。在项目中，分有几个目录，每章中会带有逐步的介绍和对应的代码，能够手把手教你使用c语言的指针数组，实现一个高效的哈希表。但美中不足之处在于，代码仍存在一些小问题，导致会出现段错误，  
如在哈希表搜索时，应当设置最大尝试次数，防止死循环
哈希表删除元素时，如果没有找到对应的键值对，不应该做ht->count–
更新哈希表大小时，应该在更新哈希表之后，删除原本的旧哈希表
通过对openclaw简单的询问以及要求，他真的会做到修改代码。
心得
“那是最好的时代，那是最坏的时代”。
]]>
    
    https://gmaxh.site/2026/04/21/Openclaw%20%E7%9A%84%E7%9B%AE%E6%A0%87%E6%98%AF%E8%A7%A3%E6%94%BE%E5%85%A8%E4%BA%BA%E7%B1%BB/
    
    2026-04-21T22:21:45.000Z
    

      Openclaw 的目标是解放全人类

    
    
    
      用cpp实现一个简单的线程池
写在前面：
线程池，顾名思义用来存放批量线程的容器。面对需要处理多任务的情况，多线程的并发处理可以有效提高运行速度。接下来我将用cpp实现一个简单的线程池类。
基本思路：
构造函数和析构函数:负责线程池的创建和销毁。
任务队列和锁:任务队列用来存放所有的任务，锁负责在线程访问任务队列时加锁，避免竞争。
线程池:用vector存放thread，worker作为工作线程，在创建时压入vector中，为每个工作线程创建任务等待环节，使用条件变量等待任务，遇到任务则唤醒线程并加锁，访问任务队列，读取任务弹出任务，解锁执行任务，如若没有任务则销毁线程，销毁线程池。
提交任务:submit函数可以接受任何任务的类型，并且支持回调。
使用者在使用线程池类的时候，需要确定好要创建的线程池中的线程数，之后通过lambda表达式处理任务提交和回调显示。
io输出使用线程安全的方式，即log函数，避免在output过程中出现错误显示。
整体界面美观，有关于主线程和工作线程在执行过程中的状态显示，供学习者参考。
源代码：
ThreadPool.h:
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
#include <iostream>
#include <vector>
#include <condition_variable>
#include <thread>
#include <queue>
#include <functional>
#include <mutex>
#include <chrono>
#include <future>
#include <iomanip>

using std::string, std::cout, std::endl;

/*
    日志处理函数:
    接受字符串参数，打印日志。
*/

void log(const string& msg) {
    static std::mutex logMtx;
    std::lock_guard<std::mutex> lg(logMtx);

    auto now = std::chrono::system_clock::now();
    auto time = std::chrono::system_clock::to_time_t(now);
    cout << msg << endl;
}

void log(const string& msg, int x) {
    static std::mutex logMtx;
    std::lock_guard<std::mutex> lg(logMtx);

    auto now = std::chrono::system_clock::now();
    auto time = std::chrono::system_clock::to_time_t(now);
    cout << msg;
}

class ThreadPool {

/*
    公共接口:构造函数和析构函数，
    自动初始化线程池，
    并且在工作完成之后结束线程池。
    定义任务提交函数。
    使用模板，接受任意可调用对象，任意对象的参数，回调函数。
    使用auto处理不确定的返回值，
    异步执行任务，自动执行回调函数，
    最后返回future对象，用来同步等待任务结果。
*/

public:
    ThreadPool(size_t TNum);
    ~ThreadPool();

    template<class F, class CB>
    auto submit(F&& f, CB&& cb) -> std::future<decltype(f())>;
      
/*
    隐藏接口:
    定义工作线程以及存放线程的数组，任务队列
    锁，条件变量，控制线程之间调度的条件
*/

private:
    void worker();// 工作线程
    std::vector<std::thread> workers;// 线程
    std::queue<std::function<void()>> jobs;// 任务队列

    std::mutex mtx;// 锁
    std::condition_variable cv;// 条件变量
    bool stop = false;// 控制条件
};

/*
    线程池构造函数:
    将创建的线程加入到vector里
*/

ThreadPool::ThreadPool(size_t TNum) {
    log("(init)初始化线程池,使用 " + std::to_string(TNum) + " 个线程");
    for(size_t i = 0; i < TNum; ++i) {
        workers.emplace_back(&ThreadPool::worker, this);
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }
    
}

/*
    线程池析构函数:
    将所有线程进行回收
*/

ThreadPool::~ThreadPool() {
    {
        std::lock_guard<std::mutex> lg(mtx);// 上锁，通知所有线程即将关闭线程池
        stop = true;
    }
    cv.notify_all();// 唤醒所有线程

    for(auto& t : workers) {
        if(t.joinable()) t.join();
    }
    log("(finish)线程池已关闭");
}

/*
    线程池工作函数:
    while循环:等待任务，期间处于休眠状态，除非线程池关闭
    锁:访问队列时加锁，执行任务时解锁
    条件变量:没有任务时休眠，有任务时加锁
    任务:如果在任务队列中检测到有任务，被唤醒之后，从队列中取出，执行任务
*/

void ThreadPool::worker() {
    log("(worker)工作线程");
    while(true) {
        std::function<void()> job;
        {
            std::unique_lock<std::mutex> ul(mtx);
            cv.wait(ul, [this]() {return stop || !jobs.empty(); });

            if(stop && jobs.empty()) {
                log("(worker)工作线程已销毁");
                return;
            }
            job = std::move(jobs.front());
            jobs.pop();
        }
        job();
    }
}

/*
    线程池任务提交函数:
    模板:声明，接受任意任务，参数，回调
    返回值:future异步处理任务结果，最后执行回调
    returnType:任务自动获取到对应任务的返回值，用于回调
    job:任务包装，加入到队列中
    上锁访问队列:加入
*/

template<class F, class CB>
auto ThreadPool::submit(F&& f, CB&& cb) -> std::future<decltype(f())> {
    using returnType = decltype(f());// 获取返回值类型

    auto job = std::make_shared<std::packaged_task<returnType()>> (
        std::forward<F>(f)
    );// 任务包装器:在让多线程共享的前提下，将任务完美包装到job里
    std::future<returnType> res = job->get_future();// 获取结果

    {// 上锁访问队列
        std::lock_guard<std::mutex> lg(mtx);
        jobs.emplace([job, cb]() {
            (*job)();
            cb();
        });
    }
    cv.notify_one();// 唤醒线程，准备工作
    log("(submit)任务已加入队列");
    return res;
}
ThreadMain.cpp:
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
#include "ThreadPool.h"

using namespace std;

// 阶乘
uint64_t factorial(int n) {
    uint64_t res = 1;
    for(int i = 2; i <= n; ++i) {
        res *= i;
        this_thread::sleep_for(chrono::milliseconds(100));// 模拟耗时长的任务
    }
    return res;
}

using Matrix = vector<vector<int>>;
// 矩阵乘法
Matrix MatrixMultiply(const Matrix& A, const Matrix& B) {
    int m = A.size();// 总数
    int n = B[0].size();// 列数
    int p = B.size();// 总数

    Matrix res(m, vector<int>(n, 0));

    for(int i = 0; i < m; ++i) {
        for(int j = 0; j < n; ++j) {
            for(int k = 0; k < p; ++k) {
                res[i][j] += A[i][k] * B[k][j];
            }
        }
    }

    return res;
}

int main() {
    ThreadPool TPool(10);

    log("(main)测试矩阵乘法:");
    Matrix A = {{1, 2}, {3, 4}};
    Matrix B = {{5, 6}, {7, 8}};

    auto MatrixFuture = TPool.submit([=]() {
        return MatrixMultiply(A, B);
    }, []() {
        log("(callback)矩阵乘法任务已完成");
    });

    Matrix C = MatrixFuture.get();

    log("(main)矩阵结果:");
    for(auto& row : C) {
        for(int x : row) {
            log(to_string(x) + " ", 1);
        }
        log(" ");
    }

    log("(main)测试阶乘:");
    int n;
    log("(main)输入计算的阶乘数字: ");
    cin >> n;
    
    auto factorialFuture = TPool.submit([=]() {
        return factorial(n);
    }, []() {
        log("(callback)阶乘任务已完成");
    });
    log("(main)阶乘结果:");
    auto facResult = factorialFuture.get();
    log("(main)" + to_string(n) + "!= " + to_string(facResult));

    return 0;
}

]]>
    
    https://gmaxh.site/2026/04/14/%E5%9C%A8%20Linux%20%E7%B3%BB%E7%BB%9F%E4%B8%AD%E5%AE%9E%E7%8E%B0%E7%BA%BF%E7%A8%8B%E6%B1%A0/
    
    2026-04-14T21:01:27.000Z
    

      用cpp实现一个简单的线程池

    
    
    
      用cpp实现一个简单的多线程排序
写在前面：
线程，可以在程序运行时线性创建，并行使用，面对数据量很大的需求，多线程并发处理很好的提速。本次我将写一个多线程排序程序。
基本思路：
排序算法: 由于要处理数据量很大的需求，应当选择小于O(n)时间复杂度的算法。这里我用的是归并排序。
分两种情况，一种是单线程排序，就是正常的排序。需要考虑一种情况，即当在多线程排序，递归创建线程时，深度大于3时，线程过多会导致程序崩溃，面对这种情况则回退到单线程。
第二种情况，即多线程排序，递归创建线程，每层创建两个，分别处理left mid, mid + 1 right。
生成数据方面，使用cpp的伪随机数据生成器。
最后生成耗时，并进行比较，有助于观察时间差距。
源代码：
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#include <iostream>
#include <mutex>
#include <thread>
#include <chrono>
#include <vector>
#include <random>
#include <algorithm>

using namespace std;
const int MAX_DEPTH = 3;// 控制线程创建的层数，避免线程创建过多
const int DATA_SIZE = 1e6;
/*

    数据生成：
    创建一个vector，之后使用伪随机数生成器
    通过一个for循环，使用auto，将生成的数据放入ector中

*/

vector<int> createData(size_t size, int minVal, int maxVal) {
    vector<int> a(size);
    random_device rd;
    mt19937 gen(rd());
    uniform_int_distribution<> dis(minVal, maxVal);// 创建均匀分布，防止数据过密
    for(auto& x : a) {
        x = dis(gen);
    }

    return a;
}

void merge(vector<int>& arr, int left, int mid, int right) {
    vector<int> temp(right - left + 1);
    int i = left, j = mid + 1, k = 0;
    while(i <= mid && j <= right) {
        if(arr[i] <= arr[j]) temp[k++] = arr[i++];
        else temp[k++] = arr[j++];
    }
    while(i <= mid) temp[k++] = arr[i++];
    while(j <= right) temp[k++] = arr[j++];
    for(int l = 0; l < temp.size(); ++l) {
        arr[left + l] = temp[l];
    }
}

void mSort(vector<int>& arr, int left, int right) {
    if(left >= right) return;
    int mid = left + (right - left) / 2;
    mSort(arr, left, mid);
    mSort(arr, mid + 1, right);
    merge(arr, left, mid, right);
}

void TmSort(vector<int>& arr, int left, int right, int d = 0) {
    if(left >= right) return;

    if(d >= MAX_DEPTH) {// 超过就使用单线程
        mSort(arr, left, right);
        return;
    }

    int mid = left + (right - left) / 2;

    // 使用引用，否则无法排序
    thread t1(TmSort, ref(arr), left, mid, d + 1);
    thread t2(TmSort, ref(arr), mid + 1, right, d + 1);
    
    t1.join();
    t2.join();

    merge(arr, left, mid, right);
}

int main() {
    vector<int> data = createData(DATA_SIZE, 1, 100000);
    auto data2 = data;// 单线程数据，进行比较

    // 多线程
    auto startTime = chrono::high_resolution_clock::now();
    TmSort(data, 0, data.size() - 1);
    auto endTime = chrono::high_resolution_clock::now();
    chrono::duration<double> temp(endTime - startTime);
    double ThreadTime = temp.count();
    cout << "多线程排序耗时:" << ThreadTime
        << "s" << endl;// 更高精度计算时间


    // 单线程
    startTime = chrono::high_resolution_clock::now();
    mSort(data2, 0, data2.size() - 1);
    endTime = chrono::high_resolution_clock::now();
    chrono::duration<double> temp2(endTime - startTime);
    double SingleTime = temp2.count();
    cout << "单线程排序耗时:" << SingleTime
        << "s" << endl;// 更高精度计算时间

    if(data == data2) {
        cout << "计算正确!" << endl;
        cout << "耗时差距为:" << chrono::duration<double>(abs(temp - temp2)).count() 
            << "s" << endl;
    }else throw domain_error("计算错误!");
    return 0;
}
]]>
    
    https://gmaxh.site/2026/04/13/%E5%9C%A8%20Linux%20%E7%B3%BB%E7%BB%9F%E4%B8%AD%E5%AE%9E%E7%8E%B0%E5%A4%9A%E7%BA%BF%E7%A8%8B%E6%8E%92%E5%BA%8F/
    
    2026-04-13T21:23:53.000Z
    

      用cpp实现一个简单的多线程排序

    
    
    2026-06-21T11:43:30.049Z
  
  
    
      FRiver
    
    
    
    
    
    
      在linux系统上使用yolov8模型
前言
大家好，本周的知识分享内容是使用yolov8来训练自己的数据集，最后将训练好的模型投入使用。
深度学习模型
深度学习模型是机器学习的一个子集，其核心是构建由多个“层”组成的人工神经网络，通过层次化特征学习，从大规模数据中自动提取从低级到高级的抽象表示。
分类:
计算机视觉:yolo,自研模型
自然语言处理:deepseek,GPT,gemini,transformer,自研模型
多模态处理:GPT,自研模型
计算机视觉
计算机视觉是人工智能的一个核心研究领域，旨在赋予计算机“看”和理解图像或视频内容的能力，其目标是从视觉数据中自动提取、分析、理解有用信息，并做出决策或表达。
yolo介绍
yolo官方文档
历史版本
应用场景
YOLO（You Only Look Once）是一种流行的物体检测和图像分割模型。YOLO 于 2015 年推出，因其高速和高精度而广受欢迎。
目标检测是一项涉及识别图像或视频流中目标的位置和类别的任务。
目标检测器的输出是一组边界框，这些边界框包围了图像中的目标，以及每个框的类别标签和置信度分数。当您需要在场景中识别感兴趣的目标，但不需要确切知道目标在哪里或其确切形状时，目标检测是一个不错的选择。
实例分割比对象检测更进一步，包括识别图像中的各个对象并将它们与图像的其余部分分割开来。
实例分割模型的输出是一组掩码或轮廓，它们勾勒出图像中每个对象，以及每个对象的类别标签和置信度分数。 当您不仅需要知道对象在图像中的位置，还需要知道它们的精确形状时，实例分割非常有用。
图像分类是三个任务中最简单的，它涉及将整个图像分类到一组预定义的类别中。
图像分类器的输出是单个类别标签和一个置信度分数。当您只需要知道图像属于哪个类别，而不需要知道该类别的对象位于何处或其确切形状时，图像分类非常有用。
前置知识
虚拟环境:是将项目需要用到的依赖放到一个统一的环境内，防止不同项目之间，需要的依赖不同而发生冲突，很有助于项目管理，yolo的官方文档中提到了很多虚拟环境工具，如conda，pythonVenv等，此处我使用的是conda，他的操作更简单，并且自动安装了CUDA。
yaml文件:在yolov8训练过程中需要配置的文件。
置信度:是目标检测模型中，表示预测结果可信程度的一个概率值，范围在 [0, 1] 之间。数值越高，表示模型对自己预测的结果越确信。
数据集:是机器学习和人工智能领域中，用于训练、验证和测试模型的结构化数据集合。它是深度学习模型的“教材”——模型通过学习数据集中的样本与标签之间的映射关系，来获得解决特定任务的能力。
训练集:
训练集是用于训练模型的数据集合，模型通过学习训练集中的图像和对应的标注信息，来调整自身的参数（权重和偏置），从而掌握识别目标的能力。
验证集:
验证集是用于评估模型训练效果和调优参数的数据集合，模型在训练过程中定期在验证集上进行测试，但不参与参数更新。
测试集:
测试集是用于最终评估模型泛化能力的数据集合，只在模型训练完成后使用一次，用于报告模型的真实性能。
标签:
class_id类别编号(从0开始)
x_center框中心点x坐标(归一化)
y_center框中心点y坐标(归一化)
width    框宽度(归一化)
height    框高度(归一化)  
过拟合:是指模型在训练集上表现非常好（损失很低、准确率很高），但在验证集或测试集上表现很差的现象。简单来说：模型死记硬背了训练数据，但没有学到通用规律，导致对新数据泛化能力差。
张量即多维数组。在计算机视觉相关的模型中，一张图片可以被转换为张量，作为参数被模型使用。
张量的存储可以在cpu上，gpu上，对于gpu上的张量可以使用CUDA进行加速。
在yolo模型中，张量作为参数，yolo模型作为函数，接受参数对其进行训练。
损失:是一个标量张量，表示模型预测结果与真实标签之间的差距。损失越小，模型预测越准。
损失函数:用来检测损失的程度。
梯度:是一个张量，表示了每个参数应该往哪个方向调整，才能让损失变小。  
前向传播：输入数据逐层计算得到预测结果和损失值的过程。
反向传播：从损失函数出发，利用链式法则反向计算每一层参数梯度的过程。
梯度下降：参数沿着梯度的反方向进行迭代更新以最小化损失函数的优化算法。
优化器：基于梯度下降原理，决定参数更新策略的算法实现。
必要的工具
vscode:支持加入很多插件，自由度更高，更灵活。
pip:是Python的官方包管理工具。
pytorch:深度学习框架，是yolov8的核心依赖。
conda:一个开源的包管理系统和环境管理系统。能创建隔离的虚拟环境，避免不同项目之间的依赖冲突。
CUDA:调用N卡的GPU对模型进行训练。
我自己的电脑配置
cpu:AMD Ryzen 7 5800H with Radeon Graphics 8核 16线程 
显卡:NVIDIA GeForce RTX 3060
内存:16GB
OS:ubuntu 25.04
环境安装
虚拟环境配置
安装conda
1
2
3
4
5
6
7
8
9
wget https://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda.sh

bash ~/miniconda.sh -b -p $HOME/miniconda3

~/miniconda3/bin/conda init fish

exec fish

conda --version
配置pip
1
2
3
sudo apt install pip

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple 
创建并激活虚拟环境
第一次创建环境会比较慢，这里在conda的配置文件中加入清华源，移除较慢的源，再进行创建。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 配置国内源
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge/
conda config --set show_channel_urls yes

# 移除速度较慢的源
conda config --remove channels defaults

# 接受 Anaconda 官方仓库（repo.anaconda.com）的服务条款
conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/main
conda tos accept --override-channels --channel https://repo.anaconda.com/pkgs/r

# 创建虚拟环境
conda create -n yolo python=3.10 -y

# 激活虚拟环境
conda activate yolo
安装pytorch
pytorch官方文档
由于在训练模型时需要用到CUDA，所以需要查询自己n卡的cuda的最高支持版本，使用下面命令查询cuda版本nvidia-smi
1
pip install torch==1.13.1+cu116 torchvision==0.14.1+cu116 torchaudio==0.13.1 --extra-index-url https://download.pytorch.org/whl/cu116
下载ultralytics(yolov8)
这里直接克隆官方的源码，并且使用pip，以可修改源码的形式安装。
使用可修改源码的形式安装，有助于我们定制个人化的yolov8模型，更有助于对yolov8源码的学习。
1
2
3
4
5
git clone git@github.com:ultralytics/ultralytics.git

cd ultralytics

pip install -e .
模型预测
在ultralytics目录下，直接运行以下命令。
1
yolo predict model=yolov8n.pt source='ultralytics/assets/bus.jpg'
数据处理
数据的选择
数据要有真实应用场景，最好不要摆拍。
选择的图片要尽可能复杂多样，有白天拍摄也有夜晚拍摄，覆盖多种情况。
样本尽可能多些。
要和目标检测的对象相关。
数据集获取与标注
数据集的获取有如下代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
import cv2

video = cv2.VideoCapture("./puerzi.mp4")
num = 0
save_step = 30

while True:
    ret, frame = video.read()
    if not ret:
        break
    num += 1
    if num % save_step == 0:
        cv2.imwrite("./demo_images/" + str(num) + ".jpg", frame)
对于数据集的标注，市面上有很多种工具和网站，https://www.makesense.ai是一个在线的标注工具，提高了标注效率。并且支持大批量文件导入，压缩包文件导出。
数据训练
文件结构方面
结构如图：
1
2
3
4
5
6
7
8
9
10
11
ultralytics/                # ultralytics 根目录
├── datasets/               # 数据集根目录
│   └── your_dataset/       # 你的数据集名称（如：coco_custom、helmet_detection）
│       ├── images/         # 图片文件夹
│       │   ├── train/      # 训练集图片
│       │   └── val/        # 验证集图片
│       └── labels/         # 标签文件夹（txt格式）
│           ├── train/      # 训练集标签
│           └── val/        # 验证集标签
├── ultralytics/            # 源码目录
└── ...
代码方面
在ultralytics的根目录下创建yaml文件和py文件，yaml文件用来确定待训练数据的位置，和训练对象。py文件用来执行YOLOV8的训练。
在py文件中，可以自行配置各种训练参数，如：
workers: 是用于并行加载数据的进程数量。当训练模型时，CPU需要不断读取图像、解码、进行数据增强等预处理操作，然后将处理好的数据传递给GPU进行训练。在win系统下，此处需要设置为0,linux系统下设置为1～8(默认为8)即可。
epochs: 训练轮数。
epoch 1-50:   快速下降阶段，模型快速学习基本特征
epoch 50-150: 缓慢下降阶段，模型优化细节
epoch 150-300: 收敛阶段，loss基本不再下降
epoch >300:   过拟合风险增加  
batch: 是模型每次迭代训练时处理的图像数量。例如batch=16意味着每次同时处理16张图像，计算梯度，然后更新一次模型参数。
查看训练结果
在runs/detect目录下，存放着YOLOV8对图片的训练结果以及训练的可视化过程。
在weights目录下，存放着best.pt和last.pt文件，一个是训练出来最好的模型，另一个供下一次训练时继续使用。
1
yolo detect predict model=runs/detect/()/weights/best.pt  source=() show=True
总结
本次知识分享，主要内容包括认识了深度学习模型的种类，计算机视觉概要，初识yolo。学习了如何使用yolov8模型，从环境安装，模型部署，模型预测，数据集收集与标注，模型训练的一系列过程。
]]>
    
    https://gmaxh.site/2026/03/26/%E5%9C%A8%20Linux%20%E7%B3%BB%E7%BB%9F%E4%B8%8A%E4%BD%BF%E7%94%A8yolov8%E6%A8%A1%E5%9E%8B/
    
    2026-03-26T17:47:36.000Z
    

      在linux系统上使用yolov8模型

    
    
    2026-06-21T11:43:30.049Z
  
  
    
      FRiver
    
    
    
    
      我自幼喜欢计算机,却没什么大理想,只想在快节奏的时代里留下自己的足迹。
本网站希望可以带给你快乐。ヽ(●´∀`●)ﾉ
行香子·在一中楼
梅柳葵菊，花谢丰收。
呢喃却，了了金秋。你追我赶，慢慢悠悠。
走菜花园，操场道，教学楼。
山高多险，风急难驻。
忘离别，晓向天涯。你说他逗，将也临冬，
过高一闹，高三静，总轻柔。

]]>
    
    https://gmaxh.site/2026/03/23/%E6%85%A2%E6%85%A2%E8%B5%B0%E4%B8%8B%E5%8E%BB/
    
    2026-03-23T17:19:00.000Z
    

      我自幼喜欢计算机,却没什么大理想,只想在快节奏的时代里留下自己的足迹。

本网站希望可以带给你快乐。ヽ(●´∀`●)ﾉ
行]]>
    
    
    2026-06-21T11:43:30.049Z
  
  
    
      FRiver
    
    
    
    
    
      用c语言实现自己的 shell
写在前面：
shell 是操作系统中，帮助用户通过命令行界面控制系统的执行文件，他随着终端创建而运行。
功能：
实现管道，输入输出重定向。
支持后台运行程序。
支持cd，包括切换到绝对路径，相对路径，切换至上一次的目录位置。
在shell内部屏蔽了 ctrl + c 等中断进程信号。
界面美观。目录显示参考了 fish 的表现方法，整体界面干净整洁。
支持大批量复制。
基本思路：
在main函数内注册好需要屏蔽的信号，之后执行firstShow，展示欢迎界面，后进入shell函数内。
以shell函数为主函数，来创建其他的函数，包括解析命令行，路径搜索，处理进程的创建和清除，处理管道，处理重定向等等。
源代码：
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
#define _GNU_SOURCE// 用来导入GNU扩展，使得中文内容编码正常
#include <fcntl.h>
#include <unistd.h>
#include <locale.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/wait.h>// 等待子进程
#include <string.h>// 字符串比较
#include <signal.h>// 中断 ctrl + c 信号

#define COLOR_RESET "\033[0m" // 重置 
#define COLOR_WELCOME "\033[1;34m" // 欢迎界面(粗体蓝色)
#define COLOR_POINT "\033[2;32m" // 高亮显示当前行指向(粗体暗绿色)
#define COLOR_HIGHLIGHT "\033[1;32m" // 高亮显示当前行索引(粗体亮绿色)
#define MAX_PATH 256
#define MAX_ARGS 64
#define MAX_BGPROCESS 128
#define MAX_PIPES 16


typedef struct {
    pid_t pid;
    char command[256];
    int isstillhere;
}Bgprocess;

typedef struct {
    char *args[MAX_ARGS];
    int argc;
    char *inputFile;
    char *outputFile;
    int appendOutput;  // 1代表>>,0代表>
    int hasPipe;
    int pipeFd[2];
} Command;

Bgprocess bgProcess[MAX_BGPROCESS];// 后台进程
int bgpCount = 0;// 后台进程数


void FirstShow();
void Shell();
void Error(int isError);
int ParseCommand(char* command, char* args[], int* isback);// 解析命令行，将token放入参数指针数组
char* SearchPath(char* command);// 路径搜索
void SignalZombie(int sig);  // 处理僵尸进程
void AddBgProcess(pid_t pid, char* command);// 添加后台进程
void CheckBgProcess(void);// 检查后台进程
void CleanCommand(Command commands[]);// 清理管道
char* simpleCurrentPath(char currentPath[]);// 简化路径显示
int isChinese(const char* str);


/*
以下三个函数先设置command结构体，之后设置重定向，最后创建进程执行管道
*/ 

int HandlePipe(Command commands[], char command[], char* args[], int* isback);// 处理管道
int setRediraction(Command commands[]);// 设置重定向
void execPipe(Command commands[], int cmdCount, int isback);// 执行管道

int main() {
    // 注册信号
    signal(SIGINT, SIG_IGN);// 解决ctrl + c中断进程的问题
    signal(SIGQUIT, SIG_IGN);// 解决ctrl + \中断进程的问题
    signal(SIGCHLD, SignalZombie);// 处理僵尸进程

    setvbuf(stdin, NULL, _IOLBF, 0);// 处理行缓冲，使得快速显示内容
    setvbuf(stdout, NULL, _IOLBF, 0);

    FirstShow();//启动整体程序
    exit(EXIT_SUCCESS);
}

int isChinese(const char* str) {
    // UTF-8中文字符的第一个字节范围：0xE4-0xE9
    unsigned char c = (unsigned char)str[0];
    return (c >= 0xE4 && c <= 0xE9);
}


char* simpleCurrentPath(char currentPath[]) {
    if(strcmp(currentPath, "/") == 0) {
        return currentPath;
    }

    char copy[MAX_PATH];    
    copy[0] = '\0';
    strcat(copy, currentPath);
    int cnt = 0;
    int cntToken = 0;

    for(int i = 0; i < strlen(currentPath); ++i) {
        if(currentPath[i] == '/') {
            cnt++;
        }
    }

    static char result[MAX_PATH] = "";
    result[0] = '\0';

    char* token = strtok(copy, "/");
    while(token && cntToken <= cnt - 2) {
        if(strcmp("home", token) == 0) {
            strcat(result, "/~");
        }else {
            strcat(result, "/");
            if(isChinese(token)) {
                strncat(result, token, 3);
            }else {
                strncat(result, token, 1);
            }
        }
        token = strtok(NULL, "/");
        cntToken++;
    }
    if(token) {
        strcat(result, "/");
        strcat(result, token);
    }

    return result;
}

/*
    清理命令资源,
    不需要清理文件名字符串，
    因为它作为指针指向原始命令字符串
*/

void CleanCommand(Command commands[]) {
    commands->argc = 0;
    commands->inputFile = NULL;
    commands->outputFile = NULL;
    commands->appendOutput = 0;
    commands->hasPipe = 0;
}

/*
    用来执行管道。
    先设置好前置管道和当前管道，
    在具有一定管道数目内，
    执行for循环创建进程。
    在子进程内，
    设置好输入输出重定向。
    之后执行进程。
    在父进程内，
    关闭前置进程，并且设置好当前进程。
    由于当前进程下的管道属于同一个进程组，同时执行，
    所以可以只记录第一个Pipepid。

*/

void execPipe(Command commands[], int cmdCount, int isback) {
    int prePipe[2] = {-1, -1};// 分别为读端，写端
    int currentPipe[2];// 分别为读端，写端
    pid_t PipePids[MAX_PIPES];

    for(int i = 0; i < cmdCount; ++i) {
        if(i < cmdCount - 1) {
            pipe(currentPipe);
        }

        switch (PipePids[i] = fork())
        {
        case -1:
            perror("fork");
            break;
            
        case 0:
            if(isback) {// 忽略ctrl + c 和 ctrl + \ 的信号
                signal(SIGINT, SIG_IGN);
                signal(SIGQUIT, SIG_IGN);
            }

            if(prePipe[0] != -1) {// 设置输入重定向
                dup2(prePipe[0], STDIN_FILENO);
                close(prePipe[0]);
                close(prePipe[1]);
            }

            if(i < cmdCount - 1) {// 设置输出重定向
                close(currentPipe[0]);
                dup2(currentPipe[1], STDOUT_FILENO);
                close(currentPipe[1]);
            }

            if(setRediraction(commands + i)) {
                exit(1);
            }
            
            for(int fd = 3; fd < 1024; ++fd) {// 关闭了
                if(fd != STDERR_FILENO && fd != STDIN_FILENO && fd != STDOUT_FILENO) {
                    close(fd);
                }
            }

            char* execPath = SearchPath(commands[i].args[0]);
            if(!execPath) {
                fprintf(stderr, "shell: %s: 未找到命令\n", commands[i].args[0]);
                exit(127);
            }

            extern char** environ;// 不可写成* environ[]的形式，这与_GNU_SOURCE中声明的冲突
            if(execve(execPath, commands[i].args, environ) == -1) {
                fprintf(stderr, "shell: %s: 执行失败\n", commands[i].args[0]);
                exit(126);
            }
            break;
        
        default:
            if(prePipe[0] != -1) {// 关闭上一个管道的fd，否则不会结束。
                close(prePipe[0]);
                close(prePipe[1]);
            }

            if(i < cmdCount - 1) {// 保存当前管道
                prePipe[0] = currentPipe[0];
                prePipe[1] = currentPipe[1];
            }
            break;
        }
    }

    if(isback) {
        char cmd[256] = "";// 后台创建进程。
        for(int i = 0; i < cmdCount; ++i) {
            if(i > 0) {
                strcat(cmd, "|");
            }
            strcat(cmd, commands[i].args[0]);
        }
        AddBgProcess(PipePids[0], cmd);
    }else {
        // 前台等待所有进程。
        for(int i = 0; i < cmdCount; ++i) {
            waitpid(PipePids[i], NULL, 0);
        }
    }
}

/*
    用来针对管道设置重定向。
    首先根据cmd结构体内的参数，
    决定是否要进行重定向。
    处理时要新开一个fd，
    即获取到当前文件，
    之后用dup2将重定向的宏，
    指定到当前文件，并且关闭之前的文件描述符fd。
    如果出错，返回-1,
    正常则返回。
*/

int setRediraction(Command commands[]) {
    if(commands->inputFile) {// 处理输入重定向
        int fd = open(commands->inputFile, O_RDONLY);
        if(fd < 0) {
            fprintf(stderr, "shell: %s: 无法打开输入文件\n", commands->inputFile);
            return -1;
        }
        dup2(fd, STDIN_FILENO);
        close(fd);
    }

    if(commands->outputFile) {
        int flags = O_WRONLY | O_CREAT;
        if(commands->appendOutput) {
            flags |= O_APPEND;
        }else {
            flags |= O_TRUNC;
        }

        int fd = open(commands->outputFile, flags, 0644);// 644 代表 所有者读写，所属组只读，其他用户只读
        if(fd < 0) {
            fprintf(stderr, "shell: %s: 无法打开输出文件\n", commands->outputFile);
            return -1;
        }
        dup2(fd, STDOUT_FILENO);
        close(fd);
    }

    return 0;
}

/*
    用来处理命令参数中的管道。
    先在一个for循环内记录非管道参数的数目。
    之后根据这个数目，
    创建一个for循环，
    在数目内设置每个command结构体的参数。
    先初始化好每个参数，
    之后根据<,>,>>，分别对每个结构体cmd内进行标记。
    如果if都被跳过了，则把当前参数标记好。
*/

int HandlePipe(Command commands[], char command[], char* args[], int* isback) {
    int countNoPipe = 0;
    int argIndex = 0;
    CleanCommand(&commands[countNoPipe]);

    while(args[argIndex]) {
        if(strcmp(args[argIndex], "|") == 0) {//遇到管道则跳过处理
            commands[countNoPipe].args[commands[countNoPipe].argc] = NULL;
            countNoPipe++;
            CleanCommand(&commands[countNoPipe]);
            argIndex++;
            continue;
        }

        // 处理参数成为管道，对每个管道开始设置标记，供后续函数进行识别
        if(strcmp("<", args[argIndex]) == 0) {
            if(args[argIndex + 1]) {
                commands[countNoPipe].inputFile = args[++argIndex];
            }
        }else if(strcmp(">", args[argIndex]) == 0) {
            if(args[argIndex + 1]) {
                commands[countNoPipe].outputFile = args[++argIndex];
                commands[countNoPipe].appendOutput = 0;
            }
        }else if(strcmp(">>", args[argIndex]) == 0) {
            if(args[argIndex + 1]) {
                commands[countNoPipe].outputFile = args[++argIndex];
                commands[countNoPipe].appendOutput = 1;
            }
        }else {
            commands[countNoPipe].args[commands[countNoPipe].argc++] = args[argIndex];
        }
        argIndex++;
    }

    commands[countNoPipe].args[commands[countNoPipe].argc] = NULL;
    commands[countNoPipe].hasPipe = 0;
    return countNoPipe + 1;// 返回命令数量
}

/*
    用来移除已经结束的进程。
    在while循环内作为检查的起始端。
    在for循环中利用冒泡排序，
    依次将整体移动，清除0位。
    如果碰到了正在运行的进程则跳过，i++
    否则进行for循环，并且减少bgpCount。
*/

void CheckBgProcess() {
    int i = 0;
    while(i < bgpCount) {
        if(!bgProcess[i].isstillhere) {
            for(int j = i; j < bgpCount - 1; j++) {
                bgProcess[j] = bgProcess[j + 1];
            }
            bgpCount--;
        }else {
            i++;
        }
    }
}

/*
    用来添加后台进程到后台进程结构体数组内。
    如果当前后台进程数少于最大进程数，
    则创建好后台进程，
    并打印好创建信息。
*/

void AddBgProcess(pid_t pid, char* command) {
    if(bgpCount < MAX_BGPROCESS) {
        bgProcess[bgpCount].pid = pid;
        bgProcess[bgpCount].isstillhere = 1;
        memcpy(bgProcess[bgpCount].command, command, 255);
        bgProcess[bgpCount].command[255] = '\0';

        printf("[ %d ] %d\n", ++bgpCount, pid);// 打印后台进程数目，进程pid
    }
}

/*
    用来处理僵尸进程。
    获取到当前进程的状态和pid，
    在while循环内通过wait no hang(不挂起等待)的方式，
    回收每个僵尸进程，
    设置好回收状态。
    并且提示给用户进程的回收状态。
*/

void SignalZombie(int sig) {
    int status;
    pid_t currentPid;

    while((currentPid = waitpid(-1, &status, WNOHANG)) > 0) {
        for(int i = 0; i < bgpCount; ++i) {
            if(bgProcess[i].pid == currentPid && bgProcess[i].isstillhere) {
                bgProcess[i].isstillhere = 0;// 设置为已回收
                printf("\n[ %d ] %s 进程已回收\n", currentPid, bgProcess[i].command);
                fflush(stdout);
                break;
            }
        }
    }
}


/*
    用来进行路径搜索。
    先获取到原本路径，
    后对原本路径复制，用复制样本进行拆分，
    把每个目录放成完整路径。
    如果绝对路径正确，则返回绝对路径，
    否则从环境变量里找到并返回完整路径。
    如果什么都没找到，返回NULL。
*/

char* SearchPath(char* command) {
    if(!command || *command == '\0') {
        return NULL;
    }

    if(command[0] == '/' || command[0] == '.') {
        if(access(command, F_OK) != 0) {
            fprintf(stderr, "shell: %s: 没有那个文件或目录\n", command);
            return NULL;
        }
        if(access(command, X_OK) != 0) {
            fprintf(stderr, "shell: %s: 权限不够\n", command);
            return NULL;
        }
        return command;
    }

    char* path = getenv("PATH");
    if(!path) {
        return NULL;
    }
    
    char *pathcopy = strdup(path); 
    char* dir = strtok(pathcopy, ":");
    static char fullpath[MAX_PATH];

    while(dir) {
        snprintf(fullpath, sizeof(fullpath), "%s/%s", dir, command);

        if(access(fullpath, F_OK) == 0) {
            if(access(fullpath, X_OK) == 0) {
                free(pathcopy);
                return fullpath;
            } else {
                free(pathcopy);
                return NULL;
            }
        }
        dir = strtok(NULL, ":");
    }
    free(pathcopy);
    fprintf(stderr, "shell: %s: 未找到命令\n", command);
    return NULL;
     
}

/*
    用来解析从用户获取到的命令行，
    拆分成token放入args参数数组。
    在while循环内拆分token，并逐个放入数组内。
*/

int ParseCommand(char* command, char* args[], int* isback) {
    int cnt = 0, len = strlen(command);
    
    *isback = 0;

    // 处理冗余内容
    char* start = command;
    while(*start == ' ' || *start == '\t') start++;

    char* end = command + len - 1;
    while(end > start && (*end == ' ' || *end == '\t' || *end == '\n')) {
        *end = '\0';
        end--;
    }

    if(end >= start && *end == '&') {
        *isback = 1;
        *end = '\0';

        end--;
        while(end >= start && (*end == ' ' || *end == '\t')) {
            *end = '\0';
            end--;
        }
    }
    // 处理冗余内容

    if(*start == '\0') {
        args[0] = NULL;
        return 0;
    }

    char* token;
    char* saveptr;
    char* p = start;
    int inQuote = 0;
    char quoteChar = 0;

    while(cnt < MAX_ARGS - 1 && *p) {
        //除杂
        while(*p == ' ' || *p == '\t') p++;
        if(*p == '\0') break;
        
        if(*p == '"' || *p == '\'') {
            inQuote = 1;
            quoteChar = *p;//确定为引号，供后续比较，确定区间
            p++; // 跳过左引号
            token = p;
            
            while(*p) {
                if(*p == quoteChar) {
                    // 如果是引号，检查前面是否是转义符
                    if(*(p-1) != '\\') {
                        break;  // 找到未被转义的右引号
                    }
                }
                p++;
            }
            
            if(*p == quoteChar) {//找到右引号
                *p = '\0';
                args[cnt++] = token;
                p++;
            }
            inQuote = 0;
        } else {
            // 普通参数
            token = p;
            while(*p && *p != ' ' && *p != '\t') p++;//除杂
            if(*p) {
                *p = '\0';
                p++;
            }
            args[cnt++] = token;
        }
    }
    args[cnt] = NULL;

    return cnt;
}

/*
    用来判断用户可能出现的错误。
    用isError存储错误参数，
    函数接受参数后执行对应错误码，给用户提示。
*/

void Error(int isError) {
    switch (isError) 
    {
    case 0:// 退出shell
        printf("\n退出shell\n");
        break;
    
    case 2:// 未获取到环境变量
        printf("\n未获取到环境变量...\n");
        break;
    default:
        break;
    }
}

/*
    shell进入的欢迎界面。
    用了2个字符串指针，之后在两层for循环中，打印界面。
    最后执行shell函数，进入shell内部。
*/

void FirstShow() {
    int time;
    char flag = '#';
    char* wl = "Welcome";
    char* wl2 = "Shell";
    for(time = 1; time <= 10; time++) {
        for(int i = 0; i < 30; i++) {
            printf("%c",flag);
            if((i == 29)) {
                printf("\n");
            }
        }
        if(time == 10 / 2) {
            for(int i = 0; i < 10; i++) {
                printf("%c",flag);
            }
            printf("%s%s%s", COLOR_WELCOME, wl, COLOR_RESET);
            for(int i = 0; i < 13; i++) {
                printf("%c",flag);
                if(i == 12) {
                    printf("\n");
                }
            }
            for(int i = 0; i < 11; i++) {
                printf("%c",flag);
            }
            printf("%s%s%s", COLOR_WELCOME, wl2, COLOR_RESET);
            for(int i = 0; i < 14; i++) {
                printf("%c",flag);
                if(i == 13) {
                    printf("\n");
                }
            }
        }
        usleep(50000);
    };
    printf("\n");
    Shell();
}

/*
    shell的主体函数。
    用command数组存储路径。
    fork出子进程之后，把在子进程内部执行execve。
    父进程等待子进程结束之后，继续保持shell状态，并且有Error错误判断。
*/

void Shell() {
    char *args[MAX_ARGS];
    char hostName[256];
    char command[1024];
    char currentPath[MAX_PATH];
    char answer[10];
    char* execpath = NULL;
    pid_t pidChild;
    int status, isback = 0;

    while(1) {

        static char prevPath[MAX_PATH] = "";

        CheckBgProcess();
        gethostname(hostName, 256);
        if(getcwd(currentPath, MAX_PATH)) {

            printf("%s@%s->%s%s%s%s ", COLOR_POINT, hostName, COLOR_RESET, COLOR_HIGHLIGHT, simpleCurrentPath(currentPath), COLOR_RESET);
        }else {
            printf("%s@%s->%s ", COLOR_POINT, hostName, COLOR_RESET);
        }

        fflush(stdout);

        if(!fgets(command, sizeof(command), stdin)) {
            if(feof(stdin)) {
                printf("\n");
                Error(0);
                exit(EXIT_SUCCESS);
            }
            continue;
        }

        // 检查是否有未闭合的引号
        int in_quote = 0;
        char quote_char = 0;
        size_t len = strlen(command);
        
        // 检查当前行的引号状态
        for(int i = 0; i < len; i++) {
            if(command[i] == '"' || command[i] == '\'') {
                if(!in_quote) {
                    in_quote = 1;
                    quote_char = command[i];
                } else if(command[i] == quote_char && (i == 0 || command[i-1] != '\\')) {
                    in_quote = 0;
                }
            }
        }

        // 如果引号未闭合，继续读取更多行
        while(in_quote) {
            char more[1024];
            fflush(stdout);
            
            if(!fgets(more, sizeof(more), stdin)) {
                break;
            }
            
            // 追加到 command
            strncat(command, more, sizeof(command) - strlen(command) - 1);
            
            // 重新检查引号状态
            len = strlen(command);
            in_quote = 0;
            for(int i = 0; i < len; i++) {
                if(command[i] == '"' || command[i] == '\'') {
                    if(!in_quote) {
                        in_quote = 1;
                        quote_char = command[i];
                    } else if(command[i] == quote_char && (i == 0 || command[i-1] != '\\')) {
                        in_quote = 0;
                    }
                }
            }
        }

        // 移除末尾的换行符
        len = strlen(command);
        if (len > 0 && command[len - 1] == '\n') {
            command[len - 1] = '\0';
            len--;
        }

        if(strcmp("exit", command) == 0 || strcmp("quit", command) == 0) {
            if(bgpCount > 0) {
                printf("当前后台还有 %d 个进程正在运行，是否要强行关闭? (y/n): ", bgpCount);
                if(fgets(answer, sizeof(answer), stdin)) {
                    if(answer[0] != 'y' && answer[0] != 'Y') {
                        continue;
                    }
                }
            }
            Error(0);
            exit(EXIT_SUCCESS); 
        }

        // 添加jobs命令，显示后台任务
        if (strcmp("jobs", command) == 0) {
            if (bgpCount == 0) {
                printf("没有后台进程\n");
            } else {
                printf("后台进程列表：\n");
                for (int i = 0; i < bgpCount; i++) {
                    printf("[%d] %d\t%s\t%s\n", 
                           i + 1, 
                           bgProcess[i].pid, 
                           bgProcess[i].isstillhere ? "运行中" : "已完成",
                           bgProcess[i].command);
                }
            }
            continue;
        }
        if(strncmp("cd", command, 2) == 0 && (command[2] == ' ' || command[2] == '\0')) {
            ParseCommand(command, args, &isback);

            if(args[1] == NULL || strcmp(args[1], "~") == 0) {
                char* home = getenv("HOME");
                if(!home) {
                    Error(2);
                }else {
                    getcwd(prevPath, MAX_PATH);
                    if(chdir(home) != 0) {
                        fprintf(stderr, "cd: %s: 无法进入目录\n", home);
                    }
                }
            }
            else if (strcmp(args[1], "-") == 0) {
                if (prevPath[0] == '\0') {
                    getcwd(prevPath, MAX_PATH);
                    continue;
                } else {
                    char tmpCurrentPath[MAX_PATH];
                    if (getcwd(tmpCurrentPath, MAX_PATH)) {
                        if(chdir(prevPath) == 0) {
                            printf("%s\n", prevPath);
                            strcpy(prevPath, tmpCurrentPath);
                        } else {
                            fprintf(stderr, "cd: %s: 无法进入目录\n", prevPath);
                        }
                    }
                }
            }else {
                char targetPath[MAX_PATH];
                if(args[1][0] == '/') {
                    strcpy(targetPath, args[1]);
                }else {
                    if(getcwd(targetPath, MAX_PATH)) {
                        strcpy(prevPath, targetPath);
                        strcat(targetPath, "/");
                        strcat(targetPath, args[1]);
                    }
                }
                if(chdir(args[1]) != 0) {
                    fprintf(stderr, "cd: %s: 没有那个文件或目录\n", args[1]);
                }
            }
            continue;
        }

        if(strchr(command, '|') != NULL || strchr(command, '>') != NULL || strchr(command, '<') != NULL) {
            Command commands[MAX_PIPES];
            ParseCommand(command, args, &isback);
            int cmdCount = HandlePipe(commands, command, args, &isback);

            if(cmdCount) {
                execPipe(commands, cmdCount, isback);
            }
            continue;
        }else {
            ParseCommand(command, args, &isback);

            if(args[0] == NULL) {
                continue;
            }

            execpath = SearchPath(args[0]);

            if(execpath == NULL) {
                continue;
            }

            switch (pidChild = fork())
            {
            case -1:
                perror("fork");
                break;
            
            case 0:
                if (isback) {
                    signal(SIGINT, SIG_IGN);
                    signal(SIGQUIT, SIG_IGN);
                }
                extern char** environ;
                if(execve(execpath, args, environ) == -1) {
                    fprintf(stderr, "shell: %s: 执行失败\n", args[0]);
                    exit(1);
                }
                break;
            default:
                if(isback) {
                    AddBgProcess(pidChild, command);
                }else {
                    waitpid(pidChild, &status, 0);
                }
                break;
            }
        }
    }
}
]]>
    
    https://gmaxh.site/2026/03/10/%E5%9C%A8%20Linux%20%E7%B3%BB%E7%BB%9F%E4%B8%AD%E5%AE%9E%E7%8E%B0%20shell/
    
    2026-03-10T20:40:24.000Z
    

      用c语言实现自己的 shell

    

    
    2026-06-21T11:43:30.049Z
  
  
    
      FRiver
    
    
    
    
      不要轻易修改你的linux系统，除非你一无所知
为什么突然想写这样一篇文章?  
起因：
起初在小组，看到学长的hyprland如此生动有趣，值得把玩，那为什么我也不试一试呢？说时迟那时快，我直接打开chrome，搜索ubuntu安装hyprland。
发展：
果然，看到网上的预览效果十分震撼我弱小的心灵，对于一个linux新用户来说，一个可自定义的桌面十分吸引人。也没管是怎么个说法，就把这份脚本下载下来了。下载的时间十分漫长，足够一个193身高的人安安静静地吃完一份晚饭，顺便买瓶阿萨姆。当我回到了小组工位上，看到hyprland下载完成。我直接注销用户，切换桌面为hyprland。他终于来了。
高潮：
hyprland凭借着他的高自由度，和充满geek风格的桌面深深吸引了我，从waybar到终端，但还有一点小小的不足，我的双显示屏并不能正常使用。那好吧，经过一番设置，也还算成功，但，无论怎样，总会有一点点小瑕疵，让这个双显示屏的切换不够丝滑。之后询问了一下d老师，d老师说这是这样那样的问题，我信了，结果，整个桌面开始变得不再正常，从waybar到终端。甚至是24级的学长都无能为力，难道只能放弃了吗？犹豫再三，我选择重装系统，就是这么暴力。
结尾：
看似故事已经结束，但故事才刚刚开始。在之后的这几天内，我似乎陷入了while 1 循环，找不到循环结束条件。从安装linux mint 的Xfce版本，到安装ubuntu25.04 又升级到25.10，没有一次是称心如意的。经过我来来回回的装系统，删系统，甚至我的小u盘也败下阵来，一插入就开始显示不正常的消息。结果这场闹剧以安装ubuntu25.04收尾。
结语：
折腾是一件好事吗？这浪费了时间，没有真正意义上提升了代码编写能力和思考业务的能力，而且徒增烦恼。但也并非如此。还记得刷视频的时候，有位文学先生，对读书的意义作出了一份恰当的总结：”读书的意义并不在于记住什么知识，而是像喝水一样，补充养分，涵养精神。“计算机的学习也大概如此。
]]>
    
    https://gmaxh.site/2025/12/22/%E4%B8%8D%E8%A6%81%E8%BD%BB%E6%98%93%E4%BF%AE%E6%94%B9%E4%BD%A0%E7%9A%84%20Linux%20%E7%B3%BB%E7%BB%9F%EF%BC%8C%E9%99%A4%E9%9D%9E%E4%BD%A0%E4%B8%80%E6%97%A0%E6%89%80%E7%9F%A5/
    
    2025-12-22T20:48:47.000Z
    

      不要轻易修改你的linux系统，除]]>
    
    
    2026-06-21T11:43:30.049Z
  
  
    
      FRiver
    
    
    
    
    
      用c语言实现自己的 sleep 命令
写在前面：
sleep是用于控制进程暂停的常用命令，本次我将使用系统调用函数，实现一个简单的sleep命令。
功能：
支持传入多个参数。
对于没有参数或这错误参数的情况，抛出错误。
基本思路：
对于没有参数的情况，我直接抛出错误。
在处理参数的时候，我这里封装在了一个Howtime()的函数内部，可以使得处理参数更加方便，而由于参数是字符串形式传入，所以需要转换为整数形式。
面对负数，非阿拉伯数字等其他字符的时候，我选择抛出错误。
最后把所有时间加和，sleep。
源代码：
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
34
35
36
37
38
39
40
41
#include <stdio.h>//fprintf()
#include <unistd.h>//sleep()
#include <stdlib.h>//exit()

int Howtime(char* string);

int main(int argc, char* argv[]) { 
  int total_time = 0;
  if(argc == 1) {
    fprintf(stderr, "sleep: argument...\n");
    exit(1);
  }
  
  for(int i = 1; i < argc; i++) {
    int tmp = Howtime(argv[i]);
    if(tmp < 0) {
      fprintf(stderr, "sleep:invalid time '%s'\n",argv[i]);
    }else {
      total_time += tmp;
    }
  }
  sleep(total_time);
  
  exit(0);
}

int Howtime(char* string) {
  if(string[0] == '-' || string[0] == '\0') {
    return -1;
  }
  int time = 0;
  int i = 0;
  while(string[i] != '\0') {
    if(string[i] < '0' && string[i] > '9') {
      return -1;
    }
    time = time * 10 + (string[i] - '0');
    i++;
  }
  return time;
}
]]>
    
    https://gmaxh.site/2025/11/18/%E5%9C%A8%20Linux%20%E7%B3%BB%E7%BB%9F%E4%B8%AD%E5%AE%9E%E7%8E%B0%20sleep%20%E5%91%BD%E4%BB%A4/
    
    2025-11-18T20:40:24.000Z
    

      用c语言实现自己的 sleep 命令

    
    
    
      用c语言实现自己的 ls 命令
写在前面：
ls是linux系统编程常用的命令行，可以实现对一个目录的展示，也可以加入不同的参数(l,a,R,……)，满足不同需求，下面是一个使用c语言编写的ls命令
功能：
实现了 ls 的 -a、-l、-R、-t、-r、-i、-s 参数，并允许这些参数任意组合。
-R 可以对 / 遍历测试。
界面美观（输出对齐、带颜色显示等）。
无资源与内存泄漏。
基本思路：
对于参数处理，我使用了宏定义，对每个参数设置了二进制位，全部的参数处理采用位运算，好处是节省空间，便于理解。
对于颜色显示，也使用了宏定义，对不同类型文件的设置不同颜色(此处请用ai搜索标准的颜色显示范例)，好处是便于理解，对于后期如果有需要改动的地方也很好改。
对于输出对齐，起初并没有思路，打算将目录下的文件放入一个自己手动malloc的堆内存里，但直到scandir()出现了。之后只需要获取到当前目录下的文件的最大字符宽度，根据该字符宽度占终端的实时宽度的比值，控制在第几次设置\n。
对于资源与内存泄漏：我直接使用了堆内存。
考虑完上述问题，剩下来的就是把这个目录展示出来，考虑到用户不会传递某个目录参数，所以对于没有目录参数的时候，需要展示当前目录下的文件，这里我使用了isfastoutput()函数。对于有目标目录的参数，需要获取到当前目录的路径，否则之后处理的时候都只是一个文件名，没有对应索引。这里使用了系统调用函数lstat()。而不使用stat()，使用lstat()的主要原因在于处理递归展示的时候，如果不使用lstat()，则会保存当前链接文件的指向，会陷入无限递归。而是用lstat()会剔除这些链接文件。
对于 -R 的实现：我在这里直接在listFiles()函数的尾部进行递归，并在每次递归中，分配一个适合大小的堆内存存储对应的文件，之后在释放文件。
源代码：
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <grp.h>
#include <pwd.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <time.h>
#include <inttypes.h>

// 掩码确定参数 
#define Ca              0b1               // 显示隐藏文件排列
#define Cl              0b10              // 详细排列
#define CR              0b100             // 递归排列    
#define Ct              0b1000            // 按照最新一次修改时间降序排列
#define Cr              0b10000           // 逆序排列
#define Ci              0b100000          // 显示inode编号排列
#define Cs              0b1000000         // 显示已用内存块数量排列

// 确定颜色
#define COLOR_RESET     "\033[0m"
#define COLOR_DIR       "\033[1;34m"    // 粗体蓝色
#define COLOR_EXE       "\033[1;32m"    // 粗体绿色
#define COLOR_LINK      "\033[1;36m"    // 粗体青色
#define COLOR_SOCKET    "\033[1;35m"    // 粗体紫色（socket）
#define COLOR_PIPE      "\033[33m"      // 黄色（管道）
#define COLOR_BLOCK     "\033[1;33m"    // 粗体黄色（块设备：u盘，固态)
#define COLOR_CHAR      "\033[1;33m"    // 粗体黄色（字符设备:键鼠）

void listFiles(const char*, int, int);//根据参数，普通列出目录下的文件
void printWithis(int, struct stat*, int, struct dirent**);//显示
int isfastoutput(int, char*[]);//命令行中传入的参数是否只有该可执行文件
int whatCommand(int, char*[]);//确定参数
int CompareListNormal(const struct dirent**, const struct dirent**);//按照字符顺序排列
int CompareListTime(const struct dirent**, const struct dirent**);//按照最新一次修改时间排列
int HowManyDirpath(int, char*[]);//确定目标路径的数量
int shouldPrintA(int, struct dirent*);//是否需要打印隐藏文件
int maxFileLength(int, struct dirent**, int, int);//确定每个文件的宽度
char* getColor(struct stat);//返回颜色

int main(int argc, char* argv[]) {
    int tmpargc = HowManyDirpath(argc, argv);
    if(isfastoutput(argc,argv)) {
        int command = whatCommand(argc, argv);
        listFiles(".", command, tmpargc);
        printf("\n");
    }else {
        int command = whatCommand(argc, argv);
        for(int i = 1; i < argc; i++) {
            listFiles(argv[i], command, tmpargc);
            printf("\n");
        }
    }
    exit(EXIT_SUCCESS);
}

char* getColor(struct stat st) {
    char* color = COLOR_RESET;
    if(S_ISDIR(st.st_mode)) color = COLOR_DIR;
    else if(S_ISLNK(st.st_mode)) color = COLOR_LINK;
    else if(S_ISSOCK(st.st_mode)) color = COLOR_SOCKET;
    else if(S_ISFIFO(st.st_mode)) color = COLOR_PIPE;
    else if(S_ISBLK(st.st_mode) || S_ISCHR(st.st_mode)) color = COLOR_BLOCK;
    else if(st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)) color = COLOR_EXE;
    return color;
}

int CompareListTime(const struct dirent** a, const struct dirent** b) {
    struct stat sta, stb;
    lstat((*a)->d_name, &sta);lstat((*b)->d_name, &stb);
    return sta.st_mtime >= stb.st_mtime ? -1 : 1;
}

int isfastoutput(int argc, char* argv[]) {
    int cnt = 0;        
    for(int i = 1; i < argc; i++) if(argv[i][0] == '-') cnt++;
    if(cnt == argc - 1) return 1;
    return 0;
}

void listFiles(const char* dirpath, int command, int tmpargc) {
    if(dirpath[0] == '-') return;
    if(access(dirpath, F_OK | X_OK) != 0) {
        fprintf(stderr, "无法访问 '%s': 没有那个文件或目录\n", dirpath);
        return;
    }
    int n, maxLength, maxName, Time, enter = 2,fullpath_size = 1024 , term_width = 80;//默认
    long long sum = 0;
    struct dirent** dp;
    struct stat st;
    struct winsize w;
    char* fullpath = (char*)malloc(sizeof(char) * fullpath_size);
    if(command & Ct) n = scandir(dirpath, &dp, NULL, CompareListTime);
    else n = scandir(dirpath, &dp, NULL, CompareListNormal);
    if(n < 0 && dirpath[0]) {
        perror("scandir");
        return;
    }
    if(tmpargc > 1) printf("%s:\n",dirpath);
    if(command & Cs) {
        for(int i = 0; i < n; ++i) {
            snprintf(fullpath, fullpath_size, "%s/%s", dirpath, dp[i]->d_name);
            lstat(fullpath, &st);
            if(!shouldPrintA(command, dp[i])) continue;
            sum += st.st_blocks / 2;
        }
        printf("总计 %lld\n",sum);
    }
    if(!(command & Cl)) {//根据是否需要详细排列，分成两种方案
        if(ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) == 0)term_width = w.ws_col;
        maxLength = maxFileLength(command, dp, n, 0);
        maxName = maxFileLength(command, dp, n, 3);
        Time = term_width / (maxLength + 4);
        Time = Time <= 0 ? 1 : Time;
        for(int i = 0; i < n && !(command & Cr); i++) {
            snprintf(fullpath, fullpath_size, "%s/%s", dirpath, dp[i]->d_name);//将几个字符串以整体的形式送到缓冲区，且函数本身可以防止溢出
            lstat(fullpath, &st);//获取文件详细信息
            if(!shouldPrintA(command, dp[i])) continue;
            if(enter > Time && i != 0) printf("\n");
            printWithis(command, &st, n, dp);
            if(enter <= Time) {
                printf("%s%*s%s  ", getColor(st), maxName, dp[i]->d_name, COLOR_RESET);
                enter++;
            }
            else {
                printf("%s%*s%s  ", getColor(st), maxName, dp[i]->d_name, COLOR_RESET);
                enter = 2;
            }
        }
        for(int i = n - 1; i >= 0 && (command & Cr); i--) {
            snprintf(fullpath, fullpath_size, "%s/%s", dirpath, dp[i]->d_name);//将几个字符串以整体的形式送到缓冲区，且函数本身可以防止溢出
            lstat(fullpath, &st);//获取文件详细信息
            if(!shouldPrintA(command, dp[i])) continue;
            if(enter > Time && i !=  n - 1) printf("\n");
            printWithis(command, &st, n, dp);
            if(enter <= Time) {
                printf("%s%*s%s  ", getColor(st), maxName, dp[i]->d_name, COLOR_RESET);
                enter++;
            }
            else {
                printf("%s%*s%s  ", getColor(st), maxName, dp[i]->d_name, COLOR_RESET);
                enter = 2;
            }
        }
    }
    else {
        char* tmbuffer = (char*)malloc(sizeof(char) * 80);
        struct stat st;
        struct tm* tm;
        struct passwd* pw;
        struct group* gr;
        char str[11];
        for(int i = 0 ; i < n && !(command & Cr); i++) {
            snprintf(fullpath, fullpath_size, "%s/%s", dirpath, dp[i]->d_name);
            lstat(fullpath, &st);
            if(!shouldPrintA(command, dp[i])) continue;
            printWithis(command, &st, n, dp);
            str[0] = '?';
            if(S_ISDIR(st.st_mode)) str[0] = 'd';
            else if(S_ISLNK(st.st_mode)) str[0] = 'l';
            else if(S_ISSOCK(st.st_mode)) str[0] = 's';
            else if(S_ISFIFO(st.st_mode)) str[0] = 'p';
            else if(S_ISBLK(st.st_mode)) str[0] = 'b';
            else if(S_ISCHR(st.st_mode)) str[0] = 'c';
            else str[0] = '-';
            str[1] = (st.st_mode & S_IRUSR) ? 'r' : '-';
            str[2] = (st.st_mode & S_IWUSR) ? 'w' : '-';
            str[3] = (st.st_mode & S_IXUSR) ? 'x' : '-';
            str[4] = (st.st_mode & S_IRGRP) ? 'r' : '-';
            str[5] = (st.st_mode & S_IWGRP) ? 'w' : '-';
            str[6] = (st.st_mode & S_IXGRP) ? 'x' : '-';
            str[7] = (st.st_mode & S_IROTH) ? 'r' : '-';
            str[8] = (st.st_mode & S_IWOTH) ? 'w' : '-';
            str[9] = (st.st_mode & S_IXOTH) ? 'x' : '-';
            str[10] = '\0';
            tm = localtime(&st.st_mtime);
            strftime(tmbuffer, fullpath_size, "%m月 %H:%M", tm);
            pw = getpwuid(st.st_uid);
            gr = getgrgid(st.st_gid);
            printf("%s %lu %s %s %ld %s %s%s%s\n", str, st.st_nlink, pw->pw_name, gr->gr_name, st.st_size, tmbuffer, getColor(st), dp[i]->d_name, COLOR_RESET);
        }
        for(int i = n - 1 ; i >= 0 && (command & Cr); i--) {
            snprintf(fullpath, fullpath_size, "%s/%s", dirpath, dp[i]->d_name);
            lstat(fullpath, &st);
            if(!shouldPrintA(command, dp[i])) continue;
            printWithis(command, &st, n, dp);
            str[0] = '?';
            if(S_ISDIR(st.st_mode)) str[0] = 'd';
            else if(S_ISLNK(st.st_mode)) str[0] = 'l';
            else if(S_ISSOCK(st.st_mode)) str[0] = 's';
            else if(S_ISFIFO(st.st_mode)) str[0] = 'p';
            else if(S_ISBLK(st.st_mode)) str[0] = 'b';
            else if(S_ISCHR(st.st_mode)) str[0] = 'c';
            else str[0] = '-';
            str[1] = (st.st_mode & S_IRUSR) ? 'r' : '-';
            str[2] = (st.st_mode & S_IWUSR) ? 'w' : '-';
            str[3] = (st.st_mode & S_IXUSR) ? 'x' : '-';
            str[4] = (st.st_mode & S_IRGRP) ? 'r' : '-';
            str[5] = (st.st_mode & S_IWGRP) ? 'w' : '-';
            str[6] = (st.st_mode & S_IXGRP) ? 'x' : '-';
            str[7] = (st.st_mode & S_IROTH) ? 'r' : '-';
            str[8] = (st.st_mode & S_IWOTH) ? 'w' : '-';
            str[9] = (st.st_mode & S_IXOTH) ? 'x' : '-';
            str[10] = '\0';
            tm = localtime(&st.st_mtime);
            strftime(tmbuffer, fullpath_size, "%m月 %H:%M", tm);
            pw = getpwuid(st.st_uid);
            gr = getgrgid(st.st_gid);
            printf("%s %lu ", str, st.st_nlink);
            if(!pw) printf("%d ",st.st_uid);
            else printf("%s ",pw->pw_name);
            if(!gr) printf("%d ",st.st_gid);
            else printf("%s ",gr->gr_name);
            printf("%ld %s %s%s%s\n", st.st_size, tmbuffer, getColor(st), dp[i]->d_name, COLOR_RESET);
        }
    }
    if(command & CR) {
        int Rarr_size = 1024;
        char** Rarr  = (char**)malloc(sizeof(char*) * Rarr_size);
        int count = 0;
        for(int i = 0; i < n && !(command & Cr); i++) {
            if(strcmp(dp[i]->d_name, ".") == 0 || strcmp(dp[i]->d_name, "..") == 0) continue;
            snprintf(fullpath, fullpath_size, "%s/%s", dirpath, dp[i]->d_name);
            lstat(fullpath, &st);
            if(S_ISDIR(st.st_mode) && shouldPrintA(command, dp[i])) {
                if((int)strlen(fullpath) >= (fullpath_size + 1)) {
                    fullpath_size *= 2;
                    fullpath = (char*)realloc(fullpath, sizeof(char) * fullpath_size);
                }
                Rarr[count] = (char*)malloc(sizeof(char) * (fullpath_size + 1));
                strcpy(Rarr[count], fullpath);
                count++;
                if(count >= Rarr_size) {
                    Rarr_size *= 2;
                    Rarr = (char**)realloc(Rarr, sizeof(char*) * Rarr_size);
                }
            }
        }
        for(int i = n - 1; i >= 0 && command & Cr; i--) {
            if(strcmp(dp[i]->d_name, ".") == 0 || strcmp(dp[i]->d_name, "..") == 0) continue;
            snprintf(fullpath, fullpath_size, "%s/%s", dirpath, dp[i]->d_name);
            lstat(fullpath, &st);
            if(S_ISDIR(st.st_mode) && shouldPrintA(command, dp[i])) {
                if((int)strlen(fullpath) >= (fullpath_size + 1)) {
                    fullpath_size *= 2;
                    fullpath = (char*)realloc(fullpath, sizeof(char) * fullpath_size);
                }
                Rarr[count] = (char*)malloc(sizeof(char) * fullpath_size + 1);
                strcpy(Rarr[count], fullpath);
                count++;
            }
        }
        for(int i = 0; i < count; i++) {
            printf("\n%s:\n", Rarr[i]);
            listFiles(Rarr[i], command, tmpargc);
        }
        for(int i = 0; i < count; i++) free(Rarr[i]);
        free(Rarr);
    }
    for(int i = 0; i < n; i++) free(dp[i]);
    free(dp);
}

int whatCommand(int argc, char* argv[]) {
    int command = 0, enter = 1;
    if(argc == 1) return 0;
    for(int i = 1; i < argc; ++i) {
        if(argv[i][0] != '-') continue;
        else {
            while(argv[i][enter] != '\0') {
                switch (argv[i][enter++]) {
                    case 'a':command |= Ca;break;
                    case 'l':command |= Cl;break;
                    case 'R':command |= CR;break;
                    case 't':command |= Ct;break;
                    case 'r':command |= Cr;break;
                    case 'i':command |= Ci;break;
                    case 's':command |= Cs;break;
                    default:fprintf(stderr, "可用选项：-a, -l, -R, -t, -r, -i, -s\n");
                       exit(EXIT_FAILURE);
                }
            }
        }
    }
    return command;
}

int CompareListNormal(const struct dirent** a, const struct dirent** b) {
    return strcmp((*a)->d_name, (*b)->d_name);
}

void printWithis(int command, struct stat* st, int n, struct dirent** dpall) {
    if(command & Ci) {
        int mask = 1;
        long int tmp = st->st_ino;
        do {
            tmp /= 10;
            mask++;
        }while(tmp > 9);
        int length = maxFileLength(command, dpall, n, 1);

        printf("%*lu ", length, st->st_ino);
    }
    if(command & Cs) {
        int mask = 1;
        long int tmp = st->st_blocks / 2;
        do {
            tmp /= 10;
            mask++;
        }while(tmp > 9);
        int length = maxFileLength(command, dpall, n, 2);

        printf("%*ld ", length, st->st_blocks / 2);
    }
}

int HowManyDirpath(int argc, char* argv[]) {
    int cnt = 0;
    for(int i = 1; i < argc; i++) if(argv[i][0] != '-') cnt++;
    return cnt;
}

int shouldPrintA(int command, struct dirent* dp) {
    if(dp->d_name[0] == '.' || strcmp(dp->d_name, "..") == 0) return (command & Ca);
    return 1;
}

int maxFileLength(int command, struct dirent** dp, int n, int res) {
    int max_name = 0, max_i = 0, max_s = 0, r = 0;
    struct stat st;
    for(int i = 0; i < n; ++i) {
        if(!shouldPrintA(command, dp[i])) continue;
        max_name = ((int)strlen(dp[i]->d_name) >= max_name ) ? (int)strlen(dp[i]->d_name) : max_name;
    }
    for(int i = 0; i < n && command & Ci; ++i) {
        if(!shouldPrintA(command, dp[i])) continue;
        int mask = 1;
        int tmp = dp[i]->d_ino;
        do {
            tmp /= 10;
            mask++;
        }while(tmp > 9);
        max_i = mask >= max_i ? mask : max_i;
    }
    for(int i = 0; i < n && command & Cs; ++i) {
        if(!shouldPrintA(command, dp[i])) continue;
        lstat(dp[i]->d_name, &st);
        int mask = 1;
        int tmp = st.st_blocks;
        do {
            tmp /= 10;
            mask++;
        }while(tmp > 9);
        max_s = mask >= max_s ? mask : max_s;
    }
    switch (res) {
        case 0:r = max_name + max_i + max_s;break;
        case 1:r = max_i;break;
        case 2:r = max_s;break;
        case 3:r = max_name;break;
    }
    return r; 
}
]]>
    
    https://gmaxh.site/2025/11/17/%E5%9C%A8%20Linux%20%E7%B3%BB%E7%BB%9F%E4%B8%AD%E5%AE%9E%E7%8E%B0%20ls%20%E5%91%BD%E4%BB%A4/
    
    2025-11-17T20:40:24.000Z
    

      用c语言实现自己的 ls 命令

    

    
    2026-06-21T11:43:30.049Z
  
  
    
      FRiver
    
    
    
    
    
      西邮 Linux 兴趣小组 2023 纳新面试题
学长寄语：长期以来，西邮Linux兴趣小组的面试题以难度之高名扬西邮校内。我们作为出题人也清楚的知道这份试题略有难度。请你动手敲一下代码。别担心，若有同学能完成一半的题目，就已经十分优秀。其次，相比于题目的答案，我们对你的思路和过程更感兴趣，或许你的答案略有瑕疵，但你正确的思路和对知识的理解足以为你赢得绝大多数的分数。最后，做题的过程也是学习和成长的过程，相信本试题对你更加熟悉的掌握C语言的一定有所帮助。祝你好运。我们东区逸夫楼FZ103见
本题目只作为西邮 Linux 兴趣小组 2023 纳新面试的有限参考。
为节省版面，本试题的程序源码省去了 #include 指令。
本试题中的程序源码仅用于考察 C 语言基础，不应当作为 C 语言「代码风格」的范例。
所有题目编译并运行于 x86_64 GNU/Linux 环境。
0. 鼠鼠我啊，要被祸害了
有1000瓶水，其中有一瓶有毒，小白鼠只要尝一点带毒的水，24小时后就会准时死亡。至少要多少只小白鼠才能在24小时内鉴别出哪瓶水有毒？  
题解：
代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include<stdio.h>

int main() {
    int b;
    scanf("%d",&b);//毒药编号
    int number=0;
    while(b>0)
    {
        if(b&1)
        {
            number++;
        }
        b>>=1;
    }
    printf("%d",number);//小鼠数量
    return 0;
}

解释：
由于有1000瓶药水，而$2^{10}$>1000，故至少需要10只小鼠。
考点：
 通过数学工具来解决实际问题的能力
1. 先预测一下~
按照函数要求输入自己的姓名试试~  
1
2
3
4
5
6
7
8
char *welcome() {
    // 请你返回自己的姓名
}
int main(void) {
    char *a = welcome();
    printf("Hi, 我相信 %s 可以面试成功!\n", a);
    return 0;
}
题解：
代码：
1
2
3
4
5
6
7
8
9
10
#include<stdio.h>

char *welcome() {
    return "FRiver";
}
int main(void) {
    char *a = welcome();
    printf("Hi, 我相信 %s 可以面试成功!\n", a);
    return 0;
}
输出结果：
 Hi, 我相信 FRiver 可以面试成功!  
解释：
在welcome()函数内，返回为一个字符串，这个字符串地址被保存在*a内。
之后在printf函数内打印这个字符串。
考点：
 字符串
2. 欢迎来到Linux兴趣小组
有趣的输出，为什么会这样子呢~
你了解 sizeof() 和 strlen() 吗？他们的区别是什么？
1
2
3
4
5
6
7
8
9
int main(void) {
    char *ptr0 = "Welcome to Xiyou Linux!";
    char ptr1[] = "Welcome to Xiyou Linux!";
    if (*ptr0 == *ptr1) {
      printf("%d\n", printf("Hello, Linux Group - 2%d", printf("")));
    }
    int diff = ptr0 - ptr1;
    printf("Pointer Difference: %d\n", diff);
}
题解：
输出结果：
 Hello, Linux Group - 2023
 Pointer Difference: 473149860(随着每次编译而变化)  
解释：
printf函数内嵌套了一些printf函数，每个函数的返回值为其需要打印内容的字符长度。由于*ptr0和*ptr1均为‘W’，故相等。在diff变量下，保存了ptr0和ptr1的差值，由于ptr1是一个数组，他保存在栈上，ptr2指向的是一个字符串字面量，具有静态存储期。故差值不定。
sizeof()运算符计算对象所占内存的大小或一个数据结构的大小。strlen()函数计算字符串的字符长度。
考点：
 printf函数返回值、存储期、sizeof()、strlen()
3. 一切都翻倍了吗
请尝试解释一下程序的输出。  
请谈谈对sizeof()和strlen()的理解吧。  
什么是sprintf()，它的参数以及返回值又是什么呢？
1
2
3
4
5
6
7
8
9
int main(void) {
    char arr[] = {'L', 'i', 'n', 'u', 'x', '\0', '!'}, str[20];
    short num = 520;
    int num2 = 1314;
    printf("%zu\t%zu\t%zu\n", sizeof(*&arr), sizeof(arr + 0),
           sizeof(num = num2 + 4));
    printf("%d\n", sprintf(str, "0x%x", num) == num);
    printf("%zu\t%zu\n", strlen(&str[0] + 1), strlen(arr + 0));
}
题解：
输出结果：
 7       8       2
 0
 4       5
解释：
sizeof()运算符对arr数组的元素数量进行计算，有7个元素故为7。arr+0说明了是对arr这个数组的入口地址计算，则其结果为8。由于赋值表达式的类型是左值的类型，则其大小为2。
sprintf其类似与printf，唯一区别就是他会把参数放到一个str数组里面，返回值为传入参数的字符数。而由于该参数是以16进制的方式输入的且有前缀，则其返回的字符数一定不等于原字符数，整体返回0。
&str[0]+1的结果为x的地址，从该地址开始，计算到\0之前的字符数。arr+0的结果为0的地址，从该地址开始，计算到\0之前的字符数。
考点：
 sizeof()、sprintf()
4. 奇怪的输出
程序的输出结果是什么？解释一下为什么出现该结果吧~
1
2
3
4
5
6
7
8
int main(void) {
    char a = 64 & 127;
    char b = 64 ^ 127;
    char c = -64 >> 6;
    char ch = a + b - c;
    printf("a = %d b = %d c = %d\n", a, b, c);
    printf("ch = %d\n", ch);
}
题解：
输出结果：
 a = 64 b = 63 c = -1
 ch = -128
解释：
01000000 & 01111111 = 01000000
01000000 ^ 01111111 = 01111111
01000000向右移6位：00000001，由于为负数，补码的结果为：11111111
ch的结果为64+63-(-1)=128，这个数超过了有符号整数的范围，补码结果为-128
考点：
 位运算、补码
5. 乍一看就不想看的函数
“人们常说互联网凛冬已至，要提高自己的竞争力，可我怎么卷都卷不过别人，只好用一些奇技淫巧让我的代码变得高深莫测。”
这个func()函数的功能是什么？是如何实现的？  
1
2
3
4
5
6
7
8
int func(int a, int b) {
    if (!a) return b;
    return func((a & b) << 1, a ^ b);
}
int main(void) {
    int a = 4, b = 9, c = -7;
    printf("%d\n", func(a, func(b, c)));
}
题解：
输出结果：
 6  
解释：
main函数内打印的数字，为整个函数传参后的返回值，参数内嵌套了函数，函数本身又在递归。
在函数内，先判断a的值，a的值为0时，返回b的值，否则递归函数。
考点：
 递归
6. 自定义过滤
请实现filter()函数：过滤满足条件的数组元素。
提示：使用函数指针作为函数参数并且你需要为新数组分配空间。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
typedef int (*Predicate)(int);
int *filter(int *array, int length, Predicate predicate,
            int *resultLength); /*补全函数*/
int isPositive(int num) { return num > 0; }
int main(void) {
    int array[] = {-3, -2, -1, 0, 1, 2, 3, 4, 5, 6};
    int length = sizeof(array) / sizeof(array[0]);
    int resultLength;
    int *filteredNumbers = filter(array, length, isPositive,
                                  &resultLength);
    for (int i = 0; i < resultLength; i++) {
      printf("%d ", filteredNumbers[i]);
    }
    printf("\n");
    free(filteredNumbers);
    return 0;
}
题解：  
代码：
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
34
35
36
37
38
39
40
41
42
43
44
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<assert.h>

typedef int (*Predicate)(int);

int *filter(int *array, int length, Predicate predicate,
            int *resultLength); /*补全函数*/

int isPositive(int num) { return num > 0; }
int main(void) {
    int array[] = {-3, -2, -1, 0, 1, 2, 3, 4, 5, 6};
    int length = sizeof(array) / sizeof(array[0]);
    int resultLength;
    int *filteredNumbers = filter(array, length, isPositive, &resultLength);
    for (int i = 0; i < resultLength; i++) {
      printf("%d ", filteredNumbers[i]);
    }
    printf("\n");
    free(filteredNumbers);
    return 0;
}

int *filter(int *array, int length, Predicate predicate,int *resultLength)
{
int cnt=0;
int* ar=(int*)malloc(sizeof(int)*length);
assert(ar);
int i;

for(i=0;i<length;i++)
{
if((*predicate)(array[i]))
{
ar[cnt]=array[i];
cnt++;
}
}

*resultLength=cnt;
return ar;

}
输出结果：
1 2 3 4 5 6   
解释：
首先定义了一个函数指针，指向的函数传入int类型的参数，返回int类型的值。
在过滤函数内，首先动态分配内存，之后使用判断函数进行判断是否大于0,之后进行赋值，并且记录有效值的个数，最后返回刚刚动态分配内存的地址，进入主函数。
考点：
 函数指针、动态分配内存
7. 静…态…
如何理解关键字static？  
static与变量结合后有什么作用？  
static与函数结合后有什么作用？  
static与指针结合后有什么作用？  
static如何影响内存分配？
题解：
解释：
即“静态”。
将变量、函数、指针声明为，一个具有文件作用域，内部连接，静态存储期的变量。
static的对象被放在静态存储区。
考点：
 static
8. 救命！指针！
数组指针是什么？指针数组是什么？函数指针呢？用自己的话说出来更好哦，下面数据类型的含义都是什么呢？
1
2
3
int (*p)[10];
const int* p[10];
int (*f1(int))(int*, int);
题解：
解释：
(*p)[10]是一个指向含有10个int类型元素数组的指针。
* p[10]是一个含有10个指向int类型指针元素的数组，且他被const修饰，无法修改其数组内容。
f1是一个接受int类型参数的函数，返回值是一个指针，即指向一个参数为int*和int类型的函数，指向的函数返回类型为int。即f1是一个函数指针。
考点：
 指针数组、数组指针、函数指针
9. 咋不循环了
程序直接运行，输出的内容是什么意思？
1
2
3
4
5
6
7
8
9
10
int main(int argc, char* argv[]) {
    printf("[%d]\n", argc);
    while (argc) {
      ++argc;
    }
    int i = -1, j = argc, k = 1;
    i++ && j++ || k++;
    printf("i = %d, j = %d, k = %d\n", i, j, k);
    return EXIT_SUCCESS;
}
题解：
输出结果：
 [1]
 i = 0, j = 1, k = 2  
解释：
argc一开始为1，之后进入while循环，argc一直递增(有补码)直到argc为0，退出循环。
表达式内，i=-1为真，j=0为假，k=1为真，没有短路，且三个变量均递增。
考点：
 短路、argc
10. 到底是不是TWO
1
2
3
4
5
6
7
8
9
10
11
#define CAL(a) a * a * a
#define MAGIC_CAL(a, b) CAL(a) + CAL(b)
int main(void) {
  int nums = 1;
  if(16 / CAL(2) == 2) {
    printf("I'm TWO(ﾉ>ω<)ﾉ\n");
  } else {
    int nums = MAGIC_CAL(++nums, 2);
  }
  printf("%d\n", nums);
}
题解：
输出结果：
 1  
解释：
CAL宏定义，没有加()，会直接“贴”到代码内，使得16 / CAL(2)结果为32
进入else语句内，创建了一个新的块作用域的nums，之后又被销毁，故main内的nums没有被改动，仍为1。
考点：
 宏、自动变量
11. 克隆困境
试着运行一下程序，为什么会出现这样的结果？
直接将s2赋值给s1会出现哪些问题，应该如何解决？请写出相应代码。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
struct Student {
    char *name;
    int age;
};

void initializeStudent(struct Student *student, const char *name,
                       int age) {
    student->name = (char *)malloc(strlen(name) + 1);
    strcpy(student->name, name);
    student->age = age;
}
int main(void) {
    struct Student s1, s2;
    initializeStudent(&s1, "Tom", 18);
    initializeStudent(&s2, "Jerry", 28);
    s1 = s2;
    printf("s1的姓名: %s 年龄: %d\n", s1.name, s1.age);
    printf("s2的姓名: %s 年龄: %d\n", s2.name, s2.age);
    free(s1.name);
    free(s2.name);
    return 0;
}
题解：
代码：
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
struct Student {
    char *name;
    int age;
};

void initializeStudent(struct Student *student, const char *name,
                       int age) {
    student->name = (char *)malloc(strlen(name) + 1);
    strcpy(student->name, name);
    student->age = age;
}
int main(void) {
    struct Student s1, s2;
    initializeStudent(&s1, "Tom", 18);
    initializeStudent(&s2, "Jerry", 28);
char *tmp_name;
int tmp_age;

tmp_name=s1.name;
s1.name=s2.name;
s2.name=tmp_name;

tmp_age=s1.age;
s1.age=s2.age;
s2.age=tmp_age;

    printf("s1的姓名: %s 年龄: %d\n", s1.name, s1.age);
    printf("s2的姓名: %s 年龄: %d\n", s2.name, s2.age);
    free(s1.name);
    free(s2.name);
    return 0;
}
输出结果：
 s1的姓名: Jerry 年龄: 28
 s2的姓名: Tom 年龄: 18  
解释：
s1 = s2是一个看起来就很危险的操作。会使得free(s1.name)找不到内存地址而无法释放。
考点：
 结构体、动态分配内存
12. 你好，我是内存
作为一名合格的C-Coder，一定对内存很敏感吧~来尝试理解这个程序吧！
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
struct structure {
    int foo;
    union {
      int integer;
      char string[11];
      void *pointer;
    } node;
    short bar;
    long long baz;
    int array[7];
};
int main(void) {
    int arr[] = {0x590ff23c, 0x2fbc5a4d, 0x636c6557, 0x20656d6f,
                 0x58206f74, 0x20545055, 0x6577202c, 0x6d6f636c,
                 0x6f742065, 0x79695820, 0x4c20756f, 0x78756e69,
                 0x6f724720, 0x5b207075, 0x33323032, 0x7825005d,
                 0x636c6557, 0x64fd6d1d};
    printf("%s\n", ((struct structure *)arr)->node.string);
}
题解：
输出结果：
 Welcome to XUPT , welcome to Xiyou Linux Group [2023]  
解释：
arr数组内存的分配是连续的。根据小端存储的方式存储数据，之后把数组强制转换为1个指向structure的指针，并且从node内的string下的地址位置8字节，即arr[2]开始读取arr的内存。
arr内存储的是一系列16进制数，这些数以1个字节的大小读取，直到读取到\0结束，并且以字符串的形式输出。
考点：
 结构体大小、小端存储、内存的精细操作
13. GNU/Linux (选做)
注：嘿！你或许对Linux命令不是很熟悉，甚至你没听说过Linux。但别担心，这是选做题，了解Linux是加分项，但不了解也不扣分哦！  
你知道cd命令的用法与 / . ~ 这些符号的含义吗？
请问你还懂得哪些与 GNU/Linux 相关的知识呢~
题解：
输出结果：
cd /:切换至根目录
cd .:切换至当前目录
cd ~:切换至用户主目录  
ls:列出目录
 touch:创建文件
 clear:清除终端页面
 ……
]]>
    
    https://gmaxh.site/2025/10/27/%E8%A5%BF%E9%82%AE%20Linux%20%E5%85%B4%E8%B6%A3%E5%B0%8F%E7%BB%84%202023%20%E7%BA%B3%E6%96%B0%E9%9D%A2%E8%AF%95%E9%A2%98/
    
    2025-10-27T22:30:23.000Z
    

      西邮 Linux 兴趣小组]]>
    
    
    2026-06-21T11:43:30.049Z
  
  
    
      FRiver
    
    
    
    
    
      西邮 Linux 兴趣小组 2024 纳新面试题
学长寄语：长期以来，西邮 Linux 兴趣小组的面试题以难度之高名扬西邮校内。我们作为出题人也清楚的知道这份试题略有难度。请你动手敲一敲代码。别担心，若有同学能完成一半的题目，就已经十分优秀。其次，相比于题目的答案，我们对你的思路和过程更感兴趣，或许你的答案略有瑕疵，但你正确的思路和对知识的理解足以为你赢得绝大多数的分数。最后，做题的过程也是学习和成长的过程，相信本试题对你更加熟悉地掌握 C 语言一定有所帮助。祝你好运。我们东区逸夫楼 FZ103 见！
本题目只作为西邮 Linux 兴趣小组 2024 纳新面试的有限参考。
为节省版面，本试题的程序源码省去了 #include 指令。
本试题中的程序源码仅用于考察 C 语言基础，不应当作为 C 语言「代码风格」的范例。
所有题目编译并运行于 x86_64 GNU/Linux 环境。
0. 聪明的吗喽
一个小猴子边上有 100 根香蕉，它要走过 50 米才能到家，每次它最多搬 50 根香蕉，（多了就拿不动了），它每走 1 米就要吃掉一根，请问它最多能把多少根香蕉搬到家里。
（提示：他可以把香蕉放下往返走，但是必须保证它每走一米都能有香蕉吃。也可以走到 n 米时，放下一些香蕉，拿着 n 根香蕉走回去重新搬 50 根。）
题解：
代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<stdio.h>

int main()
{
    int n,f;//n为所持香蕉数，f为需要走的步数
    scanf("%d %d",&n,&f);
    int tmp=n/2;//最多搬的香蕉数
    int a=tmp%3;//剩余无法满足走1步消耗3根香蕉的香蕉数
    int b=tmp/3;//在走1步消耗3根香蕉的条件下所走步数
    f-=b;//剩余步数
    printf("%d",tmp+a-f);//剩余香蕉
    
    return 0;
}
输出结果：
 18
解释：
由于小猴子一次性最多搬运50根香蕉，而在小猴子所持香蕉数大于50根的情况下，会先带着1批香蕉向前走1步，再拿1根香蕉返回上一个位置，再带着另1批香蕉向前走回刚刚向前走那1步的所在位置，即可以等效于，走1步消耗3根香蕉。
通过计算得知，这样走会剩下2根香蕉，在此刻我们再以该条件走1步，此时，小猴子所持香蕉数已经不大于50根了。我们便可以用走1步消耗1根香蕉的方式走完剩下的路程。
考点：
 通过数学工具来解决实际问题的能力
1. 西邮Linux欢迎你啊
请解释以下代码的运行结果。
1
2
3
4
5
6
int main() {
    unsigned int a = 2024;
    for (; a >= 0; a--)
        printf("%d\n", printf("Hi guys! Join Linux - 2%d", printf("")));
    return 0;
}
题解：
输出结果：
Hi guys! Join Linux - 2024(无限循环)
解释：
 a为unsigned，即为非负数，故其在自减的过程中，会在减为0时返回到int类型最大值
考点：
 unsigned、补码
2. 眼见不一定为实
输出为什么和想象中不太一样？
你了解 sizeof() 和 strlen() 吗？他们的区别是什么？
1
2
3
4
5
6
7
8
int main() {
    char p0[] = "I love Linux";
    const char *p1 = "I love Linux\0Group";
    char p2[] = "I love Linux\0";
    printf("%d\n%d\n", strcmp(p0, p1), strcmp(p0, p2));
    printf("%d\n%d\n", sizeof(p0) == sizeof(p1), strlen(p0) == strlen(p1));
    return 0;
}
题解：
输出结果：
 0
 0
 0
 1  
解释：
p0和p2的本质是一样的，p1是一个字符串指针。
strcmp函数在比较两个字符串时，碰到了两个'\0'，则停止比较，返回ASCII码。
sizeof对指针进行计算，结果为8(64位机)，对字符串进行计算，结果为字符串的长度。
考点：
 strcmp和sizeof
3. 1.1 - 1.0 != 0.1
为什么会这样，除了下面给出的一种方法，还有什么方法可以避免这个问题？
1
2
3
4
5
6
int main() {
    float a = 1.0, b = 1.1, ex = 0.1;
    printf("b - a == ex is %s\n", (b - a == ex) ? "true" : "false");
    int A = a * 10, B = b * 10, EX = ex * 10;
    printf("B - A == EX is %s\n", (B - A == EX) ? "true" : "false");
}
题解：
输出结果：
b - a == ex is false
B - A == EX is true  
解释：
a,b,c均为浮点数，其实际值在无限趋近于所给值。故a+b!=c。
将对应数乘10，其整数部分具有实际意义，小数部分在转换为int类型时被忽略，正好可以使得相加运算正确。
改进方法：  
可以使用16进制保存a,b,c这些浮点数，在确定小数后几位的情况下，16进制是精准的。
可以使用误差容忍度，float下为1e-6，double下为1e-12。
考点：
 浮点数、三元运算符
4. 听说爱用位运算的人技术都不太差
解释函数的原理，并分析使用位运算求平均值的优缺点。
1
2
3
4
5
6
7
8
int average(int nums[], int start, int end) {
    if (start == end)
        return nums[start];
    int mid = (start + end) / 2;
    int leftAvg = average(nums, start, mid);
    int rightAvg = average(nums, mid + 1, end);
    return (leftAvg & rightAvg) + ((leftAvg ^ rightAvg) >> 1);
}
题解：
输出结果：
 num[5]={1,2,3,4,5}
 3
 -解释：  
利用函数递归，将整个数组分成两个部分，分别求平均值，在把结果求平均值，得到最终结果，即分治。
优点：
避免了整数溢出的问题。
函数整体更整顿。
缺点：  
时间复杂度为O(n)  
空间复杂度为O(logn)
考点：
 位运算求平均值、算法的优化思想
5. 全局还是局部!!!
先思考输出是什么，再动动小手运行下代码，看跟自己想得结果一样不一样 >-<
1
2
3
4
5
6
7
8
9
10
11
12
13
14
int i = 1;
static int j = 15;
int func() {
    int i = 10;
    if (i > 5) i++;
    printf("i = %d, j = %d\n", i, j);
    return i % j;
}
int main() {
    int a = func();
    printf("a = %d\n", a);
    printf("i = %d, j = %d\n", i, j);
    return 0;
}
题解：
输出结果：
 i = 11, j = 15
 a = 11
 i = 1, j = 15  
解释：
程序内有两个函数，func和main，func函数内使用了静态变量j，和一个自动变量i，虽然在函数外部，还有一个变量i，但函数外部的变量i为外部链接的静态变量，他会被一个自动变量所“隐藏”。因此当我们在每次调用这个函数的时候，都会有一个自动变量i，来也匆匆去也匆匆。
而在不调用func函数的时候，自然也不会创建这个自动变量i去覆盖那个静态变量i。于是在第三行打印的时候，i是1，j是15。
考点：
 变量的作用域和存储期
6. 指针的修罗场：改还是不改，这是个问题
指出以下代码中存在的问题，并帮粗心的学长改正问题。
1
2
3
4
5
6
7
8
9
int main(int argc, char **argv) {
    int a = 1, b = 2;
    const int *p = &a;
    int * const q = &b;
    *p = 3, q = &a;
    const int * const r = &a;
    *r = 4, r = &b;
    return 0;
}
题解：  
代码：
1
2
3
4
5
6
7
8
9
10
11
#include<stdio.h>

int main(int argc, char **argv) {
    int a = 1, b = 2;
    const int *p = &a;
    int * const q = &b;
    *q = 3, p = &a;//q和p的操作恰好相反
    const int * const r = &a;
    //删除了有关r的操作
    return 0;
}
解释：
const在限定一个指针的时候，他和*的先后顺序需要细心关注一下。当*在const的左侧时，const限定了指针的地址；当*在const的右侧时，const限定了指针地址下的值；当*在const中间时，则地址和值都被限定。可以记为”左位右值“。
考点：
 const限定符
7. 物极必反？
你了解 argc 和 argv 吗，这个程序里的 argc 和 argv 是什么？
程序输出是什么？解释一下为什么。
1
2
3
4
5
6
7
8
9
int main(int argc, char *argv[]) {
    while (argc++ > 0);
    int a = 1, b = argc, c = 0;
    if (--a || b++ && c--)
        for (int i = 0; argv[i] != NULL; i++)
            printf("argv[%d] = %s\n", i, argv[i]);
    printf("a = %d, b = %d, c = %d\n", a, b, c);
    return 0;
}
题解：
输出结果：
 a = 0, b = -2147483646, c = -1  
解释：
argc为程序命令行的数量，*argv[]内保存着命令行的具体内容。
由于while循环的判断条件和终止条件在同一行内，且其执行的十一条空语句，故一定会执行到argc小于0。由于变量在计算机内以补码形式保存，故为4字节下最小值-2147483648。
在之后又进行了一次自增，把值赋给b后又自增，且在if语句内判断条件时，没有出现短路的情况，故所有操作都执行。
考点：
 argc和argv
8. 指针？数组？数组指针？指针数组？
在主函数中定义如下变量：
1
2
3
4
5
6
int main() {
    int a[2] = {4, 8};
    int(*b)[2] = &a;
    int *c[2] = {a, a + 1};
    return 0;
}
说说这些输出分别是什么？  
1
2
3
a, a + 1, &a, &a + 1, *(a + 1), sizeof(a), sizeof(&a)
*b, *b + 1, b, b + 1, *(*b + 1), sizeof(*b), sizeof(b)
c, c + 1, &c, &c + 1, **(c + 1), sizeof(c), sizeof(&c)
题解：
&a[0]
&a[1]
数组a的地址
数组a末尾的地址
8
8
8
&a[0]
&a[1]
数组a的地址
数组a末尾的地址
8
8
8
&&a[0]
&&a[1]
数组c的地址
数组c末尾的地址
8
8
8
解释：
a[2]是一个数组，(*b)[2]是一个指向含有2个元素的数组的指针，*c[2]是一个包含两个指针的数组。
&a的意思是整个数组的地址，而&a[0]是指数组的入口地址。
sizeof是计算其所占内存的大小。
考点：
 数组，指针数组，数组指针、sizeof
9. 嘻嘻哈哈，好玩好玩
在宏的魔法下，数字与文字交织，猜猜结果是什么？
1
2
3
4
5
6
7
8
9
10
11
12
#define SQUARE(x) x *x
#define MAX(a, b) (a > b) ? a : b;
#define PRINT(x) printf("嘻嘻，结果你猜对了吗，包%d滴\n", x);
#define CONCAT(a, b) a##b

int main() {
    int CONCAT(x, 1) = 5;
    int CONCAT(y, 2) = 3;
    int max = MAX(SQUARE(x1 + 1), SQUARE(y2))
    PRINT(max)
    return 0;
}
题解：
输出结果：
 嘻嘻，结果你猜对了吗，包11滴  
解释：
CONCAT的意思是，把a和b直接拼接起来，作为一个标识符。因此x1=5，y2=3。
在SQUARE中，对x1+1的操作为x1+1*x1+1，对y2的操作为y2*y2，取最大值赋值给max，打印max。
考点：
 宏
10. 我写的排序最快
写一个 your_sort 函数，要求不能改动 main 函数里的代码，对 arr1 和 arr2 两个数组进行升序排序并剔除相同元素，最后将排序结果放入 result 结构体中。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
int main() {
    int arr1[] = {2, 3, 1, 3, 2, 4, 6, 7, 9, 2, 10};
    int arr2[] = {2, 1, 4, 3, 9, 6, 8};
    int len1 = sizeof(arr1) / sizeof(arr1[0]);
    int len2 = sizeof(arr2) / sizeof(arr2[0]);

    result result;
    your_sort(arr1, len1, arr2, len2, &result);
    for (int i = 0; i < result.len; i++) {
        printf("%d ", result.arr[i]);
    }
    free(result.arr);
    return 0;
}
题解：
代码：
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#include<stdio.h>   
#include<stdlib.h> 

typedef struct
{
    int* arr;
    int len;
}result;

void your_sort(int arr1[],int len1,int arr2[],int len2,result* res);

int main()
{
    int arr1[] = {2, 3, 1, 3, 2, 4, 6, 7, 9, 2, 10};
    int arr2[] = {2, 1, 4, 3, 9, 6, 8};
    int len1 = sizeof(arr1) / sizeof(arr1[0]);
    int len2 = sizeof(arr2) / sizeof(arr2[0]);

    result result;
    your_sort(arr1, len1, arr2, len2, &result);
    for (int i = 0; i < result.len; i++) {
        printf("%d ", result.arr[i]);
    }
    free(result.arr);
    return 0;
}

void your_sort(int arr1[],int len1,int arr2[],int len2,result* res)
{
    res->arr=(int*)malloc(sizeof(int)*(len1+len2));
    int i,j;

    for(i=0;i<len1;i++)
    {
        res->arr[i]=arr1[i];
    }

    for(i=0;i<len2;i++)
    {
        res->arr[i+len1]=arr2[i];
    }

    res->len=len1+len2;

    for(i=0;i<res->len-1;i++)
    {
        for(j=0;j<=res->len-1-i;j++)
        {
            if(res->arr[j]>res->arr[j+1])
            {
                int tmp=res->arr[j];
                res->arr[j]=res->arr[j+1];   
                res->arr[j+1]=tmp;   
            }
        }
    }

    int new_size=1;

    for(i=1;i<res->len;i++)
    {
        if(res->arr[i]!=res->arr[i-1])
        {
            res->arr[new_size]=res->arr[i];
            new_size++;
        }
    }

    res->arr=(int*)realloc(res->arr,sizeof(int)*new_size);
    res->len=new_size;
}
输出结果：
 1 2 3 4 6 7 8 9 10   
解释：
首先定义了一个结构体，并且把这个结构体命名为result。
在your_sort函数内，分别进行了拼接，排序，去重三个步骤，并且使用了动态分配内存。这里的排序我使用的是冒泡排序。
考点：
 结构体访问、动态分配内存、拼接，排序，去重
11. 猜猜我是谁
在指针的迷宫中，五个数字化身为神秘的符号，等待被逐一揭示。
1
2
3
4
5
6
7
8
9
int main() {
    void *a[] = {(void *)1, (void *)2, (void *)3, (void *)4, (void *)5};
    printf("%d\n", *((char *)a + 1));
    printf("%d\n", *(int *)(char *)a + 1);
    printf("%d\n", *((int *)a + 2));
    printf("%lld\n", *((long long *)a + 3));
    printf("%d\n", *((short *)a + 4));
    return 0;
}
题解：
输出结果：
 0
 2
 2
 4
 2  
解释：
*a[]是一个指针数组。在64位机中地址为8字节，且为小端存储。
先转换为char*类型，后移动1个字节，解引用的结果为0。
先转换为char*类型，后转换为int*类型，对其4字节下的地址解引用，结果为1，1+1=2。
先转换为long long*类型，后移动8*3=24个字节，解引用的结果为4。
先转换为short*类型，后移动2*4=8字节，解引用的结果为2。
考点：
 指针的类型转换和运算
12. 结构体变小写奇遇记
计算出 Node 结构体的大小，并解释以下代码的运行结果。
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
union data {
    int a;
    double b;
    short c;
};
typedef struct node {
    long long a;
    union data b;
    void (*change)( struct node *n);
    char string[0];
} Node;
void func(Node *node) {
    for (size_t i = 0; node->string[i] != '\0'; i++)
        node->string[i] = tolower(node->string[i]);
}

int main() {
    const char *s = "WELCOME TO XIYOULINUX_GROUP!";
    Node *P = (Node *)malloc(sizeof(Node) + (strlen(s) + 1) * sizeof(char));
    strcpy(P->string, s);
    P->change = func;
    P->change(P);
    printf("%s\n", P->string);
    return 0;
}
题解：
输出结果：
 welcome to xiyoulinux_group!  
解释：
首先进行内存对齐，data为24字节，Node为40字节。
在main函数内对P进行动态内存分配，大小为40+30=70字节。
P->change = func把change函数指针指向了func，P->change(P)调用了指向的func函数。
在其中还有一个字符串变为小写的tolower()函数，使得结果最后均为小写。
考点：
 结构体和共用体内存对齐、动态内存分配、字符串常量的存储方式
13. GNU/Linux (选做)
注：嘿！你或许对Linux命令不是很熟悉，甚至没听说过Linux。
但别担心，这是选做题，了解Linux是加分项，不了解也不扣分哦！
你知道 ls 命令的用法与 / . ~ 这些符号的含义吗？
你知道 Linux 中权限 rwx 的含义吗？
请问你还懂得哪些与 GNU/Linux 相关的知识呢？
题解：
输出结果：
ls:列出文件
ls /:列出根目录下的所有目录
ls .:列出当前目录下的所有目录
ls ~:列出用户主目录下的所有目录  
r:读取权限
w:写入权限
x:执行权限
cd:更改目录
 touch:创建文件
 clear:清除终端页面
 ……
]]>
    
    https://gmaxh.site/2025/10/25/%E8%A5%BF%E9%82%AE%20Linux%20%E5%85%B4%E8%B6%A3%E5%B0%8F%E7%BB%84%202024%20%E7%BA%B3%E6%96%B0%E9%9D%A2%E8%AF%95%E9%A2%98/
    
    2025-10-25T12:47:21.000Z
    

      西邮 Linux 兴趣小组]]>
    
    
    2026-06-21T11:43:30.049Z
  
  
    
      FRiver
    
    
    
    
    
      西邮 Linux 兴趣小组 2025 纳新面试题
学长寄语：长期以来，西邮 Linux 兴趣小组的面试题以难度之高名扬西邮校内。我们作为出题人也清楚地知道这份试题略有难度。请你动手敲一敲代码。别担心，若有同学能完成一半的题目，就已经十分优秀。其次，相比于题目的答案，我们对你的思路和过程更感兴趣，或许你的答案略有瑕疵，但你正确的思路和对知识的理解足以为你赢得绝大多数的分数。最后，做题的过程也是学习和成长的过程，相信本试题对你更加熟悉地掌握 C 语言一定有所帮助。祝你好运。我们东区逸夫楼 FZ103 见！
本题目只作为西邮 Linux 兴趣小组 2025 纳新面试的有限参考。
为节省版面，本试题的程序源码省去了 include 指令。
本试题中的程序源码仅用于考察 C 语言基础，不应当作为 C 语言「代码风格」的范例。
所有题目编译并运行于 x86_64 GNU/Linux 环境。
0. 拼命的企鹅
一只企鹅在爬山，每隔一段路都会遇到一块石头。第 1 块石头重量是 a，每往上走一段路，石头重量就会变成上一段的平方。企鹅可以选择把某些石头捡起来，最后把捡到的石头重量相乘。
它怎样捡石头，才能得到重量乘积恰好是 a 的 b 次方的石头？（比如 b = 173 时， 要捡哪些石头？）
题解：
代码：
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
#include<stdio.h>

int main()
{
    int b;
    scanf("%d",&b);
    int printpoint=1;//insert ','.
    int point=1;//the situation of the key stone.

    while(b>0)
    {
        if(b&1)//get the key.
        {
            if(!printpoint)
            {
                printf(",");
            }
            printf("%d",point);
            printpoint=0;
        }
        b>>=1;//delete the previous.
        point++;//change the situation.
    }

    return 0;
}
输出结果：
 当b = 173时，结果为：1,3,4,6,8
 当b = 65时，结果为：1,7
解释：
由题意可知，捡到的石头重量相乘，即对应石头指数相加，而我们可以将石头的重量：${a^n}$可以写作$a^{2^n}$，于是在相乘的过程中，可以等效转换为是2的n次幂的相加，即2进制转10进制。
通过每次对2进制下的1读取下标，便可以输出1的位置。
考点：
 2进制与10进制转换、通过数学工具来解决实际问题的能力
1. 西邮Linux欢迎你啊
请解释以下代码的运行结果。
1
2
3
4
5
6
int main() {
    if (printf("Hi guys! ") || printf("Xiyou Linux ")) {
        printf("%d\n", printf("Welcome to Xiyou Linux 2%d", printf("")));
    }
    return 0;
}
题解：
输出结果：
Hi guys! Welcome to Xiyou Linux 2025
解释：  
if语句中执行printf函数，其返回值：打印的字符长度10，作为判断if语句成立的条件。由于两个printf的关系为或，第一个printf函数的返回值已经使if语句成立，故不执行第二个printf函数。结果为：Hi guys! 
在if语句内，printf函数嵌套了其他printf函数，从内向外依次输出，对应的返回值作为输出内容，以%d的形式输出。结果为：Welcome to Xiyou Linux 2025。
考点：
“短路”、printf函数返回值
2. 可以和 \0 组一辈子字符串吗？
你能找到成功打印的语句吗？你能看出每个 if 中函数的返回值吗？这些函数各有什么特点？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int main() {
    char p1[] = { 'W', 'e', 'l', 'c', 'o', 'm', 'e', '\0' };
    char p2[] = "Join us\0", p4[] = "xiyou_linux_group";
    const char* p3 = "Xiyou Linux Group\0\n2025\0";
    if (strcmp(p1, p2)) {
        printf("%s to %s!\n", p1, p2);
    }
    if (strlen(p3) > sizeof(p3)) {
        printf("%s", p3);
    }
    if (sizeof(p1) == sizeof(p2)) {
        printf("%s", p4);
    }
    return 0;
}
题解：
输出结果：
 Welcome to Join us!
 Xiyou Linux Group
解释：
第一个if语句判断中，strcmp函数进行了两个字符串的比较，由于'w'比'J'在字符表中更靠前，其ASCII码差值为正(非0)，则if语句成立，执行printf函数。
sizeof(p3)是对指针的大小进行计算，则其值为8，strlen(p3)是对字符串整体的大小进行计算，在第一个'\0'停止且不包括'\0'，故其值为17，比较结果在if语句中成立，执行printf函数。
两个字符串的大小相等，故其if语句成立，执行printf函数。
考点：
 sizeof和strlen的使用
3. 数学没问题，浮点数有鬼
这个程序的输出是什么？解释为什么会这样？
1
2
3
4
5
6
7
int main() {
    float a1 = 0.3, b1 = 6e-1, sum1 = 0.9;
    printf("a1 + b1 %s sum1\n", (a1 + b1 == sum1) ? "==" : "!=");
    float a2 = 0x0.3p0, b2 = 0x6p-4, sum2 = 0x0.9p0;
    printf("a2 + b2 %s sum2\n", (a2 + b2 == sum2) ? "==" : "!=");
    return 0;
}
题解：
输出结果：
 a1 + b1 != sum1
 a2 + b2 == sum2
解释：
浮点数本身并不精确，实际值在对应精度下无限趋近于所给值。故不相等。  
三个数均为16进制数，其实际值即所给值。
 16进制转10进制：若无小数，则10进制数=整数*2的n次方(n为p后数值)
考点：
 16进制转10进制、浮点数
4. 不合群的数字
在一个数组中，所有数字都出现了偶数次，只有两个数字出现了奇数次，请聪明的你帮我看看以下的代码是如何找到这两个数字的呢？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void findUndercoverIDs(int nums[], int size) {
    int xorAll = 0,id_a = 0,id_b = 0;
    for (int i = 0; i < size; i++) {
        xorAll ^= nums[i];
    }
    int diffBit = xorAll & -xorAll;
    for (int i = 0; i < size; i++) {
        if(nums[i] & diffBit){
            id_a ^= nums[i];
        } else {
            id_b ^= nums[i];
        }
    }
    printf("These nums are %d %d\n", id_a, id_b);
}
题解：
输出结果：
 两个出现奇数次的数字
解释：
 整体函数巧妙地利用了位运算，得到了出现奇数次的两个数字。
根据异或的特点，即两个相同的数字的结果为0，进行异或运算。如若有两个数字出现了偶数次，便会在异或中被消除，于是我们得到了两个出现奇数次的数字异或的结果，即xorAll。
对xorAll与其本身的相反数(反码+1，即补码)进行位与运算。于是我们便得到了最低位的1。
对数组进行遍历，并在if语句条件判断中进行位与操作，如果结果成立，则把对应值赋给id_a，否则把对应值给id_b。这个操作更精妙之处，在于通过每次的异或，不仅仅进行赋值操作，更去除了出现偶数次的数。
分别输出两个出现奇数次的数字。
考点：
 位运算的进阶操作
5. 会一直循环吗？
你了解 argc 和 argv 吗，程序的输出是什么？为什么会这样？
1
2
3
4
5
6
7
8
9
10
11
int main(int argc, char* argv[]) {
    printf("argc = %d\n", argc);
    while (argc++ > 0) {
        if(argc < 0){
            printf("argv[0] %s\n", argv[0]);
            break;
        }
    }
    printf("argc = %d\n", argc);
    return 0;
}
题解：
输出结果：
 argc = 1
 argv[0] ./文件
 argc = -2147483648  
解释：
打印了argc的数量，即第一次我们调用程序时，输入的命令行(./文件名称)
在while循环内进行了argc的判断与自增，并且在其中加入了argc的判断。argc在不断自增的过程中，由于其本身便是int类型，故会增加到一定大小后，变成负数。当变为负数时，if语句成立，输出argv[0]，跳出while循环，不会argc的自增~
输出argc的大小。
考点：
 argc与argv[]的含义
6. const 与指针：谁能动，谁不能动？
1
2
3
4
5
6
7
8
9
10
11
12
13
struct P {
    int x;
    const int y;
};

int main() {
    struct P p1 = { 10, 20 }, p2 = { 30, 40 };
    const struct P p3 = { 50, 60 };
    struct P* const ptr1 = &p1;
    const struct P* ptr2 = &p2;
    const struct P* const ptr3 = &p3;
    return 0;
}
说说下列操作是否合法，并解释原因：
ptr1->x = 100, ptr2->x = 300, ptr3->x = 500
ptr1->y = 200, ptr1 = &p2, ptr2->y = 400
ptr2 = &p1, ptr3->y = 600, ptr3 = &p1
题解：
输出结果：
合法
不合法
不合法
不合法
不合法
不合法
合法
不合法
不合法
解释：
首先定义了一个结构体，在结构体内有两个变量，x是int类型，y是const int类型，即无法通过指针改变y的值。
p1指针锁定了他指向的位置，p2指针锁定了他指向的内容，p3指针锁定了他指向的位置和内容。三个指针的区别就在于const的修饰。*在const前，在const后，在两个const中间。鉴于博主本人在学习此处时容易混淆，于是自己想了个小口诀，针对*在const的相对位置，“左位右值”（高中记物理二级结论的DNA动了）。供大家参考。
考点：
 const限定符、结构体
7. 指针！数组!
在主函数中定义如下变量:
1
2
3
4
5
6
7
int main() {
    int a[3] = { 2, 4, 8 };
    int(*b)[3] = &a;
    int* c[3] = { a, a + 1, a + 2 };
    int (*f1(int))(int*, int);
    return 0;
}
说说这几个表达式的输出分别是什么？
a, *b, *b + 1, b, b + 1, * (*b + 1), c, sizeof(a), sizeof(b), sizeof(&a), sizeof(f1)
题解：
输出结果：
 a:a[0]的地址
 *b:a[0]的地址
 *b + 1:a[1]的地址
 b:a的地址
 b + 1:a末尾的地址
 * (*b + 1):4
 c:a[0]的地址的地址
 sizeof(a):3(元素个数)*4(int字节大小)=12
 sizeof(b):8
 sizeof(&a):8
 sizeof(f1):编译错误
解释：
a[3]是一个含有三个int类型的数组
 (*b)[3]是一个指向含有三个int元素类型的数组的指针
 * c[3]是一个含有三个指向int指针类型的数组
 f1是一个函数，他接受一个int类型的参数，返回为函数指针，该函数指针又可以接受一个int类型指针与int类型的参数，返回为int类型
sizeof函数不可以操作函数。
考点：
 sizeof的使用、数组，数组指针，指针数组的区别、函数指针（十分神奇的一项操作）
8. 全局还是局部！！！
观察程序输出，思考为什么？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int g;
int func() {
    static int j = 98;
    j += g;
    return j;
}

int main() {
    g += 3;
    char arr[6] = {};
    arr[1] = func();
    arr[0] = func();
    arr[2] = arr[3] = func() + 1;
    arr[4] = func() + 1;
    printf("%s linux\n",arr);
    return 0;
}
题解：
输出结果：
 hello linux
解释：
arr[0]:h
 arr[1]:e
 arr[2]:l
 arr[3]:l
 arr[4]:$o$  
在调用函数的过程中，每次j变量被增加，返回值被赋给了对应数组元素。
static静态局部变量下，初始化只进行一次，且j变量存储在数据段。
考点：
 静态局部变量、ASCII码
9. 宏函数指针
观察程序结果，说说程序运行的过程：
1
2
3
4
5
6
7
8
9
10
#define CALL_MAIN(main, x) (*(int (*)(int))*main)(x);
#define DOUBLE(x) 2 * x
int (*registry[1])(int);
int main(int argc) {
    if (argc > 2e3) return 0;
    printf("%d ", argc + 1);
    *registry = (int(*)(int))main;
    CALL_MAIN(registry, DOUBLE(argc + 1));
    return 0;
}
题解：
输出结果：
 2 4 8 16 32 64 128 256 512 1024   
解释：
首先，(int (*)(int))是一个函数指针，他保存的是他所指函数的地址，并且在CALL_MAIN内，把main函数强制转换为一个函数指针，由于这个函数指针的地址就是他本身，main函数，即他在指向自己。在这个函数指针内，他接受一个int类型的变量，返回int类型，这个函数也恰好符合main函数的声明。
由于这个函数在不断的递归自己，则需要一个跳出递归的条件，即在宏定义处的DOUBLE起到了作用。通过每次的运算改变argc的值，并且加入if语句来判断是否结束该函数，便成功的解决了无限递归的问题。
resistry在声明时也是个函数指针，但是他本身是一个存储1个元素的数组，元素类型为int类型的指针。于是在resistry[0]内，保存的是指向main函数的函数指针。
在CALL_MAIN处，调用main函数，进行argc的运算，实现函数递归。
考点：
 宏定义、函数指针、函数指针数组
10. 拼接 排序 去重
本题要求你编写以下函数，不能改动 main 函数里的代码。实现对 arr1 和 arr2 的拼接、排序和去重。你需要自行定义 result 结构体并使用 malloc 手动开辟内存。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int main() {
    int arr1[] = { 6, 1, 2, 1, 9, 1, 3, 2, 6, 2 };
    int arr2[] = { 4, 2, 2, 1, 6, 2 };
    int len1 = sizeof(arr1) / sizeof(arr1[0]);
    int len2 = sizeof(arr2) / sizeof(arr2[0]);

    struct result result;
    your_concat(arr1, len1, arr2, len2, result);
    print_result(result);
    your_sort(result);
    print_result(result);
    your_dedup(result);
    print_result(result);
    free(result.arr);
    return 0;
}
题解：
代码：
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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
#include<stdio.h>
#include<stdlib.h>
struct result
{
    int* arr;
    int size;
};

void your_concat(int arr1[],int len1,int arr2[],int len2,struct result* res);
void print_result(struct result res);
void your_sort(struct result* res);
void sort(int arr[],int low,int high);//it's a qsort.
void swap(int* a,int* b);
void your_dedup(struct result* res);

int main() {
    int arr1[] = { 6, 1, 2, 1, 9, 1, 3, 2, 6, 2 };
    int arr2[] = { 4, 2, 2, 1, 6, 2 };
    int len1 = sizeof(arr1) / sizeof(arr1[0]);
    int len2 = sizeof(arr2) / sizeof(arr2[0]);

    struct result result;
    your_concat(arr1, len1, arr2, len2, &result);
    print_result(result);
    your_sort(&result);
    print_result(result);
    your_dedup(&result);
    print_result(result);
    free(result.arr);
    return 0;
}

void your_concat(int arr1[],int len1,int arr2[],int len2,struct result* res)
{
    res->arr=(int*)malloc((len1+len2)*sizeof(int));
    int i;

    for(i=0;i<len1;i++)
    {
        res->arr[i]=arr1[i];
    }
    
    for(i=0;i<len2;i++)
    {
        res->arr[len1+i]=arr2[i];
    }
    res->size=len1+len2;
}

void print_result(struct result res)
{
    int i;
    for(i=0;i<res.size;i++)
    {
        printf("%d ",res.arr[i]);
    }
    printf("\n");
}

void your_sort(struct result* res)
{
    sort(res->arr,0,res->size-1);
}

void sort(int arr[],int low,int high)
{
    int i=low;
    int j=high;
    int key=arr[low];
    if(i>j)
    {
        return;
    }
    while(i<j)
    {
        while(i<j && arr[j]>=key)
        {
            j--;
        }

        while(i<j && arr[i]<=key)
        {
            i++;
        }
        if(i<j)
        {
            swap(&arr[i],&arr[j]);
        }
        
    }
    swap(&arr[low],&arr[i]);
    sort(arr,low,i-1);
    sort(arr,i+1,high);
}

void swap(int* a,int* b)
{
    int tmp=*a;
    *a=*b;
    *b=tmp;
}

void your_dedup(struct result* res)
{
    if(res->size<=1)
    {
        return;
    }
    int new_size=1;
    int i;

    for(i=1;i<res->size;i++)
    {
        if(res->arr[i]!=res->arr[i-1])
        {
            res->arr[new_size]=res->arr[i];
            new_size++;
        }
    }

    res->arr=(int*)realloc(res->arr,new_size*sizeof(int));
    res->size=new_size;
}
输出结果：
 6 1 2 1 9 1 3 2 6 2 4 2 2 1 6 2
 1 1 1 1 2 2 2 2 2 2 3 4 6 6 6 9
 1 2 3 4 6 9  
解释：
首先定义结构体，其中结构体有int类型的指针，和我们将要进行动态操作的数组。
在拼接函数内，首先为结构体内指针分配内存，用两个for循环，将两个数组依次输入到我们刚刚分配内存的指针内。我们之后的操作也是基于这个数组。记得把大小也赋值给结构体内，保存长度的size变量。
在排序函数内，我使用的是快速排序。
在去重函数内，我对数组进行for循环遍历，由于该数组已经排序完毕，所以可以依次比较。最后将去重后的数组重新分配内存，并且重新赋值数组大小。
记得free内存。
考点：
 结构体、排序算法、动态分配内存
11. 指针魔法
用你智慧的眼睛，透过这指针魔法的表象，看清其本质：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void magic(int(*pa)[6], int** pp) {
    **pp += (*pa)[2];
    *pp = (*pa) + 5;
    **pp -= (*pa)[0];
    *pp = (*pa) + ((*(*pa + 3) & 1) ? 3 : 1);
    *(*pp) += *(*pp - 1);
    *pp = (*pa) + 2;
}
int main() {
    int a[6] = { 2, 4, 6, 8, 10, 12 };
    int* p = a + 1,** pp = &p;
    magic(&a, pp);
    printf("%d %d\n%d %d %d\n%d %d\n",*p,**pp,a[1],a[2],a[3],a[5],p-a);
    return 0;
}
题解：
输出结果：
6 6
12 6 8
10 2  
解释：
在main函数内，先分配了一个数组，并且定义了一级指针p，和二级指针pp。此时p内为a[1]的地址，pp为a[1]的地址的地址。接下来我们在magic函数内逐步分析。
首先magic函数内传入了一个指向6个元素数组的指针的参数，和一个二级指针的参数。
第一行，a[2]的值和a[1]的值相加，赋给了pp。此时数组状态为{ 2, 10, 6, 8, 10, 12 }。
第二行，把a[5]的地址赋给了pp。此时数组状态为{ 2, 10, 6, 8, 10, 12 }。
第三行，把a[5]的值和a[0]的值相减，赋给了a[5]。此时数组状态为{ 2, 10, 6, 8, 10, 10 }。
第四行，先在内层进行判断，如果a[3]的值和1位与之后，结果非0，则把1作为参数，执行外层的代码。最终结果是把a[1]的地址赋值给了pp。此时数组状态为{ 2, 10, 6, 8, 10, 10 }。
第五行，把a[1]和a[0]的值相加，赋给了a[1]。此时数组状态为{ 2, 12, 6, 8, 10, 10 }。
第六行，把a[2]的地址赋给了pp。此时数组状态为{ 2, 12, 6, 8, 10, 10 }。
最后printf函数输出时，*p和**pp为6，p-a为2，即元素位置之差。其他对应输出相应数组元素即可。
考点：
 数组指针、二级指针
12. 奇怪的循环
你能看明白这个程序怎样运行吗？试着理解这个程序吧！
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
union data {
    void**** p;
    char arr[20];
};
typedef struct node {
    int a;
    union data b;
    void (*use)(struct node* n);
    char string[0];
} Node;
void func2(Node* node);

void func1(Node* node) {
    node->use = func2;
    printf("%s\n", node->string);
}
void func2(Node* node) {
    node->use = func1;
    printf("%d\n", ++(node->a));
}
int main() {
    const char* s = "Your journey begins here!";
    Node* P = (Node*)malloc(sizeof(Node) + (strlen(s) + 1) * sizeof(char));
    strcpy(P->string, s);
    P->use = func1;
    P->a = sizeof(Node) * 50 + sizeof(union data);
    while (P->a < 2028) {
        P->use(P);
    }
    free(P);
    return 0;
}
题解：
输出结果：
 Your journey begins here!
2025
Your journey begins here!
2026
Your journey begins here!
2027
Your journey begins here!
2028  
解释：
首先在计算sizeof(Node)时，要注意结构体和共用体的内存对齐，对于共用体来说，内存共用且为最长字节类型的最小整数倍，即24。对结构体来说，每个变量对齐时，其对齐位置为上一次对齐后的下一位，为最长字节类型的倍数，总内存为最小整数倍，即40。
use函数指针指向了func1，在进入while循环内，伴随着每一次条件的判断，在func1和func2来回交替执行，直到条件不成立。
考点：
 结构体和共用体内存对齐、函数指针
13. GNU/Linux (选做)
注：嘿！你或许对 Linux 命令不是很熟悉，甚至你没听说过 Linux。但别担心，这是选做题，了解 Linux 是加分项，但不了解也不扣分哦！
你知道 cd 命令的用法与 / ~ - 这些符号的含义吗？
你知道 Linux 系统如何创建和删除一个目录吗？
请问你还懂得哪些与 GNU/Linux 相关的知识呢？
题解：
输出结果：
cd:更改目录
 cd /:切换至根目录
 cd ~:切换至用户主目录
 cd -:切换至上一级目录
mkdir 目录名称 
 rmdir 目录名称
ls:列出文件
 touch:创建文件
 clear:清除终端页面
 ……
D
]]>
    
    https://gmaxh.site/2025/10/23/%E8%A5%BF%E9%82%AE%20Linux%20%E5%85%B4%E8%B6%A3%E5%B0%8F%E7%BB%84%202025%20%E7%BA%B3%E6%96%B0%E9%9D%A2%E8%AF%95%E9%A2%98/
    
    2025-10-23T18:23:11.000Z
    

      西邮 Linux 兴趣小组]]>
    
    
    2026-06-21T11:43:30.049Z