银河麒麟操作系统C语言编程实战教程从零开始学习国产系统开发核心技术详解环境搭建语法基础程序调试与性能优化打造高效稳定应用程序

1. 银河麒麟操作系统概述

银河麒麟操作系统是由中国国防科技大学研制的基于Linux的国产操作系统，是我国自主研发的重要操作系统之一。它具有高安全性、高稳定性、高兼容性等特点，广泛应用于政府、军队、金融、能源等关键领域。

银河麒麟操作系统内核基于Linux，并进行了大量优化和定制，使其更适合中国的国情和安全需求。系统支持多种处理器架构，包括x86、ARM、MIPS等，具有良好的硬件兼容性。

在银河麒麟操作系统上进行C语言开发，可以充分利用系统的稳定性和安全性，打造符合国产化要求的应用程序。随着国家对信息安全和自主可控的重视，掌握银河麒麟操作系统上的C语言开发技术变得越来越重要。

2. 开发环境搭建

2.1 系统安装与配置

首先，我们需要安装银河麒麟操作系统。可以从官方网站下载最新的银河麒麟操作系统镜像文件，然后制作启动盘进行安装。

安装完成后，需要进行系统更新和基本配置：

# 更新系统软件包 sudo apt update sudo apt upgrade # 安装基本的开发工具 sudo apt install build-essential

2.2 开发工具安装

在银河麒麟操作系统上，我们可以使用多种C语言开发工具，包括GCC编译器、GDB调试器、Make构建工具等。

# 安装GCC编译器 sudo apt install gcc # 安装GDB调试器 sudo apt install gdb # 安装Make构建工具 sudo apt install make # 安装CMake构建工具 sudo apt install cmake # 安装IDE（如VSCode） sudo apt install code

2.3 开发环境配置

配置开发环境，包括设置环境变量、安装必要的库文件等。

# 设置环境变量 echo 'export PATH=$PATH:/usr/local/bin' >> ~/.bashrc source ~/.bashrc # 安装常用的开发库 sudo apt install libc6-dev sudo apt install libssl-dev sudo apt install libcurl4-openssl-dev

2.4 验证开发环境

创建一个简单的C程序，验证开发环境是否配置正确。

// hello.c #include <stdio.h> int main() { printf("Hello, Galaxy Kylin OS!n"); return 0; }

编译并运行程序：

gcc -o hello hello.c ./hello

如果程序输出”Hello, Galaxy Kylin OS!“，则说明开发环境配置成功。

3. C语言语法基础

3.1 基本数据类型和变量

C语言提供了多种基本数据类型，包括整型、浮点型、字符型等。

#include <stdio.h> int main() { // 整型 int a = 10; short b = 20; long c = 30; long long d = 40; // 无符号整型 unsigned int e = 50; unsigned short f = 60; unsigned long g = 70; unsigned long long h = 80; // 浮点型 float i = 3.14f; double j = 2.71828; long double k = 1.41421L; // 字符型 char l = 'A'; // 输出变量值 printf("int a = %dn", a); printf("short b = %hdn", b); printf("long c = %ldn", c); printf("long long d = %lldn", d); printf("unsigned int e = %un", e); printf("unsigned short f = %hun", f); printf("unsigned long g = %lun", g); printf("unsigned long long h = %llun", h); printf("float i = %fn", i); printf("double j = %lfn", j); printf("long double k = %Lfn", k); printf("char l = %cn", l); return 0; }

3.2 运算符和表达式

C语言提供了丰富的运算符，包括算术运算符、关系运算符、逻辑运算符、位运算符等。

#include <stdio.h> int main() { int a = 10, b = 20; // 算术运算符 printf("a + b = %dn", a + b); // 加法 printf("a - b = %dn", a - b); // 减法 printf("a * b = %dn", a * b); // 乘法 printf("a / b = %dn", a / b); // 除法 printf("a %% b = %dn", a % b); // 取模 // 关系运算符 printf("a == b = %dn", a == b); // 等于 printf("a != b = %dn", a != b); // 不等于 printf("a > b = %dn", a > b); // 大于 printf("a < b = %dn", a < b); // 小于 printf("a >= b = %dn", a >= b); // 大于等于 printf("a <= b = %dn", a <= b); // 小于等于 // 逻辑运算符 printf("a && b = %dn", a && b); // 逻辑与 printf("a || b = %dn", a || b); // 逻辑或 printf("!a = %dn", !a); // 逻辑非 // 位运算符 printf("a & b = %dn", a & b); // 按位与 printf("a | b = %dn", a | b); // 按位或 printf("a ^ b = %dn", a ^ b); // 按位异或 printf("~a = %dn", ~a); // 按位取反 printf("a << 1 = %dn", a << 1); // 左移 printf("a >> 1 = %dn", a >> 1); // 右移 // 赋值运算符 a += b; // 等同于 a = a + b printf("a += b, a = %dn", a); a -= b; // 等同于 a = a - b printf("a -= b, a = %dn", a); a *= b; // 等同于 a = a * b printf("a *= b, a = %dn", a); a /= b; // 等同于 a = a / b printf("a /= b, a = %dn", a); a %= b; // 等同于 a = a % b printf("a %%= b, a = %dn", a); return 0; }

3.3 控制流程语句

C语言提供了多种控制流程语句，包括条件语句和循环语句。

#include <stdio.h> int main() { // if-else语句 int a = 10; if (a > 0) { printf("a是正数n"); } else if (a < 0) { printf("a是负数n"); } else { printf("a是零n"); } // switch语句 char grade = 'B'; switch (grade) { case 'A': printf("优秀n"); break; case 'B': printf("良好n"); break; case 'C': printf("及格n"); break; default: printf("不及格n"); break; } // for循环 printf("for循环:n"); for (int i = 0; i < 5; i++) { printf("i = %dn", i); } // while循环 printf("while循环:n"); int j = 0; while (j < 5) { printf("j = %dn", j); j++; } // do-while循环 printf("do-while循环:n"); int k = 0; do { printf("k = %dn", k); k++; } while (k < 5); // break和continue printf("break和continue:n"); for (int i = 0; i < 10; i++) { if (i == 3) { continue; // 跳过本次循环 } if (i == 7) { break; // 退出循环 } printf("i = %dn", i); } return 0; }

3.4 函数

函数是C语言中的基本模块，用于实现特定功能的代码块。

#include <stdio.h> // 函数声明 int add(int a, int b); void printMessage(); int factorial(int n); int main() { // 调用函数 int result = add(5, 3); printf("5 + 3 = %dn", result); printMessage(); int n = 5; printf("%d! = %dn", n, factorial(n)); return 0; } // 函数定义：实现两个数相加 int add(int a, int b) { return a + b; } // 函数定义：打印消息 void printMessage() { printf("这是一个函数示例n"); } // 函数定义：计算阶乘（递归） int factorial(int n) { if (n == 0 || n == 1) { return 1; } else { return n * factorial(n - 1); } }

3.5 数组和字符串

数组和字符串是C语言中常用的数据结构。

#include <stdio.h> #include <string.h> int main() { // 一维数组 int arr[5] = {1, 2, 3, 4, 5}; printf("一维数组:n"); for (int i = 0; i < 5; i++) { printf("arr[%d] = %dn", i, arr[i]); } // 二维数组 int matrix[3][3] = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} }; printf("n二维数组:n"); for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { printf("matrix[%d][%d] = %d ", i, j, matrix[i][j]); } printf("n"); } // 字符串 char str1[] = "Hello"; char str2[] = "Galaxy Kylin OS"; printf("n字符串:n"); printf("str1 = %sn", str1); printf("str2 = %sn", str2); // 字符串连接 char str3[50]; strcpy(str3, str1); strcat(str3, " "); strcat(str3, str2); printf("连接后的字符串: %sn", str3); // 字符串长度 printf("str1的长度: %lun", strlen(str1)); printf("str2的长度: %lun", strlen(str2)); // 字符串比较 if (strcmp(str1, str2) == 0) { printf("str1和str2相等n"); } else { printf("str1和str2不相等n"); } return 0; }

3.6 指针

指针是C语言的重要特性，用于存储变量的地址。

#include <stdio.h> int main() { int a = 10; int *p; // 声明指针变量 p = &a; // 将变量a的地址赋给指针p printf("变量a的值: %dn", a); printf("变量a的地址: %pn", &a); printf("指针p的值: %pn", p); printf("指针p指向的值: %dn", *p); // 通过指针修改变量的值 *p = 20; printf("修改后，变量a的值: %dn", a); // 指针和数组 int arr[5] = {1, 2, 3, 4, 5}; int *ptr = arr; // 数组名表示数组的首地址 printf("n通过指针遍历数组:n"); for (int i = 0; i < 5; i++) { printf("arr[%d] = %dn", i, *(ptr + i)); } // 指针和函数 void swap(int *x, int *y); int x = 5, y = 10; printf("n交换前: x = %d, y = %dn", x, y); swap(&x, &y); printf("交换后: x = %d, y = %dn", x, y); return 0; } // 通过指针交换两个数的值 void swap(int *x, int *y) { int temp = *x; *x = *y; *y = temp; }

3.7 结构体和联合体

结构体和联合体是C语言中用于组合不同类型数据的构造类型。

#include <stdio.h> #include <string.h> // 定义结构体 struct Student { char name[50]; int age; float score; }; // 定义联合体 union Data { int i; float f; char str[20]; }; int main() { // 结构体变量的定义和初始化 struct Student student1 = {"张三", 18, 90.5}; struct Student student2; // 结构体成员的访问 printf("学生1的信息:n"); printf("姓名: %sn", student1.name); printf("年龄: %dn", student1.age); printf("分数: %.1fn", student1.score); // 结构体变量的赋值 strcpy(student2.name, "李四"); student2.age = 19; student2.score = 85.0; printf("n学生2的信息:n"); printf("姓名: %sn", student2.name); printf("年龄: %dn", student2.age); printf("分数: %.1fn", student2.score); // 结构体指针 struct Student *pStudent = &student1; printf("n通过指针访问学生1的信息:n"); printf("姓名: %sn", pStudent->name); printf("年龄: %dn", pStudent->age); printf("分数: %.1fn", pStudent->score); // 联合体 union Data data; data.i = 10; printf("n联合体存储整数: %dn", data.i); data.f = 220.5; printf("联合体存储浮点数: %.1fn", data.f); strcpy(data.str, "Hello C"); printf("联合体存储字符串: %sn", data.str); // 注意：联合体所有成员共享同一块内存，修改一个成员会影响其他成员 printf("修改字符串后，整数的值变为: %dn", data.i); printf("修改字符串后，浮点数的值变为: %.1fn", data.f); return 0; }

3.8 文件操作

C语言提供了丰富的文件操作函数，用于读写文件。

#include <stdio.h> #include <stdlib.h> int main() { // 写文件 FILE *fpWrite; fpWrite = fopen("test.txt", "w"); if (fpWrite == NULL) { printf("无法打开文件n"); exit(1); } fprintf(fpWrite, "这是一个测试文件n"); fprintf(fpWrite, "银河麒麟操作系统C语言编程n"); fclose(fpWrite); // 读文件 FILE *fpRead; char buffer[100]; fpRead = fopen("test.txt", "r"); if (fpRead == NULL) { printf("无法打开文件n"); exit(1); } printf("文件内容:n"); while (fgets(buffer, 100, fpRead) != NULL) { printf("%s", buffer); } fclose(fpRead); // 二进制文件读写 struct Student { char name[50]; int age; float score; }; struct Student student = {"张三", 18, 90.5}; // 写二进制文件 FILE *fpBinWrite; fpBinWrite = fopen("student.dat", "wb"); if (fpBinWrite == NULL) { printf("无法打开文件n"); exit(1); } fwrite(&student, sizeof(struct Student), 1, fpBinWrite); fclose(fpBinWrite); // 读二进制文件 struct Student studentRead; FILE *fpBinRead; fpBinRead = fopen("student.dat", "rb"); if (fpBinRead == NULL) { printf("无法打开文件n"); exit(1); } fread(&studentRead, sizeof(struct Student), 1, fpBinRead); fclose(fpBinRead); printf("n从二进制文件读取的学生信息:n"); printf("姓名: %sn", studentRead.name); printf("年龄: %dn", studentRead.age); printf("分数: %.1fn", studentRead.score); return 0; }

4. 程序调试技术

4.1 GDB调试器基础

GDB是GNU项目开发的调试器，是C语言开发中常用的调试工具。

// debug_example.c #include <stdio.h> int add(int a, int b) { int result = a + b; return result; } int main() { int x = 5; int y = 10; int sum = add(x, y); printf("%d + %d = %dn", x, y, sum); return 0; }

使用GDB调试程序：

# 编译程序，添加调试信息 gcc -g -o debug_example debug_example.c # 启动GDB gdb debug_example # 在GDB中设置断点 (gdb) break add (gdb) break main # 运行程序 (gdb) run # 单步执行 (gdb) next (gdb) step # 查看变量值 (gdb) print a (gdb) print b (gdb) print result # 查看堆栈信息 (gdb) backtrace # 继续执行 (gdb) continue # 退出GDB (gdb) quit

4.2 常见调试技巧

4.2.1 打印调试信息

在代码中添加打印语句，输出变量的值和程序执行流程。

#include <stdio.h> int factorial(int n) { printf("计算 %d 的阶乘n", n); if (n == 0 || n == 1) { printf("返回 1n"); return 1; } else { int result = n * factorial(n - 1); printf("%d! = %dn", n, result); return result; } } int main() { int n = 5; printf("计算 %d 的阶乘n", n); int result = factorial(n); printf("最终结果: %d! = %dn", n, result); return 0; }

4.2.2 条件编译

使用条件编译，在调试版本中包含调试代码，在发布版本中排除调试代码。

#include <stdio.h> #define DEBUG 1 int add(int a, int b) { #ifdef DEBUG printf("add函数被调用，参数: a = %d, b = %dn", a, b); #endif int result = a + b; #ifdef DEBUG printf("add函数返回结果: %dn", result); #endif return result; } int main() { int x = 5; int y = 10; #ifdef DEBUG printf("主函数开始执行n"); #endif int sum = add(x, y); printf("%d + %d = %dn", x, y, sum); #ifdef DEBUG printf("主函数执行结束n"); #endif return 0; }

4.2.3 断言

使用断言检查程序中的假设条件，当条件不满足时终止程序。

#include <stdio.h> #include <assert.h> int divide(int a, int b) { // 断言b不为0 assert(b != 0); return a / b; } int main() { int a = 10; int b = 2; int result = divide(a, b); printf("%d / %d = %dn", a, b, result); b = 0; // 这行代码会导致断言失败，程序终止 result = divide(a, b); printf("%d / %d = %dn", a, b, result); return 0; }

4.3 内存调试工具

4.3.1 Valgrind

Valgrind是一个内存调试工具，可以检测内存泄漏、非法内存访问等问题。

// memory_leak.c #include <stdio.h> #include <stdlib.h> void create_memory_leak() { // 分配内存但不释放 int *ptr = (int *)malloc(sizeof(int) * 10); *ptr = 10; printf("内存泄漏示例: %dn", *ptr); } void illegal_memory_access() { int arr[5] = {1, 2, 3, 4, 5}; // 访问数组越界 printf("非法内存访问: %dn", arr[10]); } int main() { create_memory_leak(); illegal_memory_access(); return 0; }

使用Valgrind检测内存问题：

# 编译程序 gcc -g -o memory_leak memory_leak.c # 使用Valgrind检测内存问题 valgrind --leak-check=full ./memory_leak

4.3.2 AddressSanitizer

AddressSanitizer是GCC和Clang提供的内存错误检测工具。

# 编译程序，启用AddressSanitizer gcc -g -fsanitize=address -o memory_leak memory_leak.c # 运行程序 ./memory_leak

5. 性能优化

5.1 代码优化技巧

5.1.1 循环优化

循环是程序中的常见结构，优化循环可以显著提高程序性能。

#include <stdio.h> #include <time.h> #define ARRAY_SIZE 1000000 // 未优化的循环 void unoptimized_loop(int *arr, int size) { for (int i = 0; i < size; i++) { arr[i] = arr[i] * 2; } } // 优化后的循环：减少循环内的计算 void optimized_loop1(int *arr, int size) { int factor = 2; for (int i = 0; i < size; i++) { arr[i] = arr[i] * factor; } } // 优化后的循环：循环展开 void optimized_loop2(int *arr, int size) { int i; for (i = 0; i < size - 4; i += 4) { arr[i] = arr[i] * 2; arr[i+1] = arr[i+1] * 2; arr[i+2] = arr[i+2] * 2; arr[i+3] = arr[i+3] * 2; } // 处理剩余元素 for (; i < size; i++) { arr[i] = arr[i] * 2; } } int main() { int arr[ARRAY_SIZE]; // 初始化数组 for (int i = 0; i < ARRAY_SIZE; i++) { arr[i] = i; } clock_t start, end; double cpu_time_used; // 测试未优化的循环 start = clock(); unoptimized_loop(arr, ARRAY_SIZE); end = clock(); cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC; printf("未优化的循环耗时: %f 秒n", cpu_time_used); // 测试优化后的循环1 start = clock(); optimized_loop1(arr, ARRAY_SIZE); end = clock(); cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC; printf("优化后的循环1耗时: %f 秒n", cpu_time_used); // 测试优化后的循环2 start = clock(); optimized_loop2(arr, ARRAY_SIZE); end = clock(); cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC; printf("优化后的循环2耗时: %f 秒n", cpu_time_used); return 0; }

5.1.2 函数调用优化

减少函数调用开销可以提高程序性能。

#include <stdio.h> #include <time.h> #define ARRAY_SIZE 1000000 // 简单的函数调用 int square(int x) { return x * x; } // 使用内联函数减少调用开销 static inline int inline_square(int x) { return x * x; } int main() { int arr[ARRAY_SIZE]; int result[ARRAY_SIZE]; // 初始化数组 for (int i = 0; i < ARRAY_SIZE; i++) { arr[i] = i; } clock_t start, end; double cpu_time_used; // 测试普通函数调用 start = clock(); for (int i = 0; i < ARRAY_SIZE; i++) { result[i] = square(arr[i]); } end = clock(); cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC; printf("普通函数调用耗时: %f 秒n", cpu_time_used); // 测试内联函数调用 start = clock(); for (int i = 0; i < ARRAY_SIZE; i++) { result[i] = inline_square(arr[i]); } end = clock(); cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC; printf("内联函数调用耗时: %f 秒n", cpu_time_used); // 测试直接计算（无函数调用） start = clock(); for (int i = 0; i < ARRAY_SIZE; i++) { result[i] = arr[i] * arr[i]; } end = clock(); cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC; printf("直接计算耗时: %f 秒n", cpu_time_used); return 0; }

5.1.3 内存访问优化

优化内存访问模式可以提高缓存命中率，从而提高程序性能。

#include <stdio.h> #include <stdlib.h> #include <time.h> #define ROWS 1000 #define COLS 1000 // 按行访问：缓存友好 void row_major_access(int matrix[ROWS][COLS]) { int sum = 0; for (int i = 0; i < ROWS; i++) { for (int j = 0; j < COLS; j++) { sum += matrix[i][j]; } } printf("按行访问的和: %dn", sum); } // 按列访问：缓存不友好 void column_major_access(int matrix[ROWS][COLS]) { int sum = 0; for (int j = 0; j < COLS; j++) { for (int i = 0; i < ROWS; i++) { sum += matrix[i][j]; } } printf("按列访问的和: %dn", sum); } int main() { int (*matrix)[COLS] = malloc(ROWS * sizeof(*matrix)); // 初始化矩阵 for (int i = 0; i < ROWS; i++) { for (int j = 0; j < COLS; j++) { matrix[i][j] = i * COLS + j; } } clock_t start, end; double cpu_time_used; // 测试按行访问 start = clock(); row_major_access(matrix); end = clock(); cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC; printf("按行访问耗时: %f 秒n", cpu_time_used); // 测试按列访问 start = clock(); column_major_access(matrix); end = clock(); cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC; printf("按列访问耗时: %f 秒n", cpu_time_used); free(matrix); return 0; }

5.2 编译器优化选项

GCC编译器提供了多种优化选项，可以自动优化代码。

// optimization_example.c #include <stdio.h> #define ARRAY_SIZE 1000000 void compute(int *arr, int size) { for (int i = 0; i < size; i++) { arr[i] = arr[i] * 2 + 1; } } int main() { int arr[ARRAY_SIZE]; // 初始化数组 for (int i = 0; i < ARRAY_SIZE; i++) { arr[i] = i; } compute(arr, ARRAY_SIZE); // 输出部分结果 for (int i = 0; i < 10; i++) { printf("arr[%d] = %dn", i, arr[i]); } return 0; }

使用不同的优化选项编译程序：

# 无优化 gcc -o optimization_example0 optimization_example.c # 基本优化 (-O1) gcc -O1 -o optimization_example1 optimization_example.c # 更高级的优化 (-O2) gcc -O2 -o optimization_example2 optimization_example.c # 最高级别的优化 (-O3) gcc -O3 -o optimization_example3 optimization_example.c # 针对特定CPU架构的优化 gcc -O3 -march=native -o optimization_example_native optimization_example.c

5.3 性能分析工具

5.3.1 gprof

gprof是GNU性能分析工具，可以分析程序的运行时间和函数调用频率。

# 编译程序，添加性能分析支持 gcc -pg -o optimization_example optimization_example.c # 运行程序，生成性能数据 ./optimization_example # 使用gprof分析性能数据 gprof optimization_example gmon.out > analysis.txt

5.3.2 perf

perf是Linux系统提供的性能分析工具，可以分析CPU性能、缓存命中率等。

# 使用perf记录程序运行数据 perf record -g ./optimization_example # 使用perf报告分析结果 perf report

6. 打造高效稳定应用程序

6.1 错误处理机制

良好的错误处理机制是应用程序稳定性的基础。

#include <stdio.h> #include <stdlib.h> #include <errno.h> #include <string.h> // 自定义错误码 typedef enum { SUCCESS = 0, ERROR_NULL_POINTER, ERROR_INVALID_PARAMETER, ERROR_MEMORY_ALLOCATION, ERROR_FILE_OPEN, ERROR_FILE_READ, ERROR_FILE_WRITE } ErrorCode; // 错误消息 const char* error_messages[] = { "成功", "空指针错误", "无效参数", "内存分配失败", "文件打开失败", "文件读取失败", "文件写入失败" }; // 错误处理函数 void handle_error(ErrorCode error_code, const char* additional_info) { if (error_code != SUCCESS) { fprintf(stderr, "错误: %s", error_messages[error_code]); if (additional_info != NULL) { fprintf(stderr, " - %s", additional_info); } if (errno != 0) { fprintf(stderr, " - %s", strerror(errno)); } fprintf(stderr, "n"); exit(error_code); } } // 文件操作示例 ErrorCode read_file_content(const char* filename, char** content, size_t* content_size) { FILE* file = NULL; ErrorCode error = SUCCESS; // 检查参数 if (filename == NULL || content == NULL || content_size == NULL) { return ERROR_INVALID_PARAMETER; } // 打开文件 file = fopen(filename, "r"); if (file == NULL) { return ERROR_FILE_OPEN; } // 获取文件大小 fseek(file, 0, SEEK_END); *content_size = ftell(file); fseek(file, 0, SEEK_SET); // 分配内存 *content = (char*)malloc(*content_size + 1); if (*content == NULL) { fclose(file); return ERROR_MEMORY_ALLOCATION; } // 读取文件内容 if (fread(*content, 1, *content_size, file) != *content_size) { free(*content); *content = NULL; fclose(file); return ERROR_FILE_READ; } // 添加字符串结束符 (*content)[*content_size] = ''; // 关闭文件 fclose(file); return SUCCESS; } int main(int argc, char* argv[]) { if (argc < 2) { printf("用法: %s <文件名>n", argv[0]); return 1; } char* content = NULL; size_t content_size = 0; ErrorCode error = read_file_content(argv[1], &content, &content_size); handle_error(error, argv[1]); printf("文件内容 (%lu 字节):n%sn", content_size, content); free(content); return 0; }

6.2 内存管理

良好的内存管理是应用程序高效运行的关键。

#include <stdio.h> #include <stdlib.h> #include <string.h> // 内存分配函数，带错误检查 void* safe_malloc(size_t size) { void* ptr = malloc(size); if (ptr == NULL) { fprintf(stderr, "内存分配失败: 无法分配 %lu 字节n", size); exit(EXIT_FAILURE); } return ptr; } // 内存重新分配函数，带错误检查 void* safe_realloc(void* ptr, size_t size) { void* new_ptr = realloc(ptr, size); if (new_ptr == NULL) { fprintf(stderr, "内存重新分配失败: 无法分配 %lu 字节n", size); free(ptr); exit(EXIT_FAILURE); } return new_ptr; } // 字符串复制函数，带内存分配 char* safe_strdup(const char* s) { if (s == NULL) { return NULL; } char* copy = safe_malloc(strlen(s) + 1); strcpy(copy, s); return copy; } // 动态数组示例 typedef struct { int* data; size_t size; size_t capacity; } IntArray; // 创建动态数组 IntArray* int_array_create(size_t initial_capacity) { IntArray* array = safe_malloc(sizeof(IntArray)); array->data = safe_malloc(sizeof(int) * initial_capacity); array->size = 0; array->capacity = initial_capacity; return array; } // 释放动态数组 void int_array_free(IntArray* array) { if (array != NULL) { free(array->data); free(array); } } // 向动态数组添加元素 void int_array_push(IntArray* array, int value) { if (array->size >= array->capacity) { // 扩容 size_t new_capacity = array->capacity * 2; array->data = safe_realloc(array->data, sizeof(int) * new_capacity); array->capacity = new_capacity; } array->data[array->size++] = value; } // 获取动态数组元素 int int_array_get(IntArray* array, size_t index) { if (index >= array->size) { fprintf(stderr, "数组索引越界: %lu >= %lun", index, array->size); exit(EXIT_FAILURE); } return array->data[index]; } int main() { // 使用安全内存分配函数 int* numbers = safe_malloc(sizeof(int) * 10); for (int i = 0; i < 10; i++) { numbers[i] = i * i; } printf("数字数组: "); for (int i = 0; i < 10; i++) { printf("%d ", numbers[i]); } printf("n"); free(numbers); // 使用字符串复制函数 char* message = safe_strdup("Hello, 银河麒麟操作系统!"); printf("消息: %sn", message); free(message); // 使用动态数组 IntArray* array = int_array_create(5); for (int i = 0; i < 20; i++) { int_array_push(array, i * 2); } printf("动态数组内容: "); for (size_t i = 0; i < array->size; i++) { printf("%d ", int_array_get(array, i)); } printf("n"); printf("数组大小: %lu, 容量: %lun", array->size, array->capacity); int_array_free(array); return 0; }

6.3 多线程编程

多线程编程可以提高应用程序的并发性能。

#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> #define NUM_THREADS 5 #define ARRAY_SIZE 10000000 // 线程参数 typedef struct { int* array; size_t start; size_t end; int factor; } ThreadArgs; // 线程函数 void* process_array(void* arg) { ThreadArgs* args = (ThreadArgs*)arg; for (size_t i = args->start; i < args->end; i++) { args->array[i] *= args->factor; } return NULL; } int main() { int* array = malloc(sizeof(int) * ARRAY_SIZE); if (array == NULL) { perror("内存分配失败"); exit(EXIT_FAILURE); } // 初始化数组 for (size_t i = 0; i < ARRAY_SIZE; i++) { array[i] = i % 100; } pthread_t threads[NUM_THREADS]; ThreadArgs thread_args[NUM_THREADS]; // 计算每个线程处理的元素数量 size_t elements_per_thread = ARRAY_SIZE / NUM_THREADS; // 创建线程 for (int i = 0; i < NUM_THREADS; i++) { thread_args[i].array = array; thread_args[i].start = i * elements_per_thread; thread_args[i].end = (i == NUM_THREADS - 1) ? ARRAY_SIZE : (i + 1) * elements_per_thread; thread_args[i].factor = 2; if (pthread_create(&threads[i], NULL, process_array, &thread_args[i]) != 0) { perror("线程创建失败"); exit(EXIT_FAILURE); } } // 等待所有线程完成 for (int i = 0; i < NUM_THREADS; i++) { pthread_join(threads[i], NULL); } // 验证结果 int success = 1; for (size_t i = 0; i < ARRAY_SIZE; i++) { if (array[i] != (i % 100) * 2) { printf("验证失败: array[%lu] = %d, 期望值: %dn", i, array[i], (i % 100) * 2); success = 0; break; } } if (success) { printf("多线程处理成功完成!n"); } free(array); return 0; }

6.4 网络编程

网络编程是现代应用程序的重要组成部分。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #define PORT 8080 #define BUFFER_SIZE 1024 // 错误处理函数 void handle_error(const char* msg) { perror(msg); exit(EXIT_FAILURE); } // 简单的TCP服务器 void run_server() { int server_fd, new_socket; struct sockaddr_in address; int opt = 1; int addrlen = sizeof(address); char buffer[BUFFER_SIZE] = {0}; // 创建套接字 if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) { handle_error("套接字创建失败"); } // 设置套接字选项 if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) { handle_error("设置套接字选项失败"); } address.sin_family = AF_INET; address.sin_addr.s_addr = INADDR_ANY; address.sin_port = htons(PORT); // 绑定套接字 if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) { handle_error("绑定失败"); } // 监听连接 if (listen(server_fd, 3) < 0) { handle_error("监听失败"); } printf("服务器正在监听端口 %d...n", PORT); // 接受连接 if ((new_socket = accept(server_fd, (struct sockaddr *)&address, (socklen_t*)&addrlen)) < 0) { handle_error("接受连接失败"); } // 读取数据 int valread = read(new_socket, buffer, BUFFER_SIZE); printf("收到消息: %sn", buffer); // 发送响应 char* response = "Hello from 银河麒麟操作系统服务器!"; send(new_socket, response, strlen(response), 0); printf("响应消息已发送n"); // 关闭套接字 close(new_socket); close(server_fd); } // 简单的TCP客户端 void run_client() { int sock = 0; struct sockaddr_in serv_addr; char buffer[BUFFER_SIZE] = {0}; // 创建套接字 if ((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) { handle_error("套接字创建失败"); } serv_addr.sin_family = AF_INET; serv_addr.sin_port = htons(PORT); // 将IP地址从文本转换为二进制形式 if (inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr) <= 0) { handle_error("无效地址/地址不支持"); } // 连接服务器 if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) { handle_error("连接失败"); } // 发送消息 char* message = "Hello from 银河麒麟操作系统客户端!"; send(sock, message, strlen(message), 0); printf("消息已发送n"); // 读取响应 int valread = read(sock, buffer, BUFFER_SIZE); printf("收到响应: %sn", buffer); // 关闭套接字 close(sock); } int main(int argc, char* argv[]) { if (argc != 2) { printf("用法: %s <server|client>n", argv[0]); return 1; } if (strcmp(argv[1], "server") == 0) { run_server(); } else if (strcmp(argv[1], "client") == 0) { run_client(); } else { printf("无效参数: %sn", argv[1]); printf("用法: %s <server|client>n", argv[0]); return 1; } return 0; }

6.5 实战项目：简单的Web服务器

下面是一个简单的Web服务器实现，综合运用了前面介绍的各种技术。

#include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> #include <pthread.h> #include <sys/stat.h> #include <ctype.h> #define PORT 8080 #define BUFFER_SIZE 4096 #define MAX_THREADS 10 // 错误处理宏 #define ERROR_EXIT(msg) do { perror(msg); exit(EXIT_FAILURE); } while(0) // HTTP响应结构 typedef struct { char* header; char* body; size_t body_length; } HttpResponse; // 线程参数 typedef struct { int client_socket; struct sockaddr_in client_address; } ThreadArgs; // 初始化HTTP响应 void http_response_init(HttpResponse* response) { response->header = NULL; response->body = NULL; response->body_length = 0; } // 释放HTTP响应资源 void http_response_free(HttpResponse* response) { if (response->header != NULL) { free(response->header); } if (response->body != NULL) { free(response->body); } http_response_init(response); } // 设置HTTP响应状态 void http_response_set_status(HttpResponse* response, int status_code, const char* status_text) { char header[BUFFER_SIZE]; snprintf(header, BUFFER_SIZE, "HTTP/1.1 %d %srn", status_code, status_text); if (response->header != NULL) { free(response->header); } response->header = strdup(header); } // 设置HTTP响应头 void http_response_set_header(HttpResponse* response, const char* name, const char* value) { char* new_header; int header_len = response->header ? strlen(response->header) : 0; new_header = realloc(response->header, header_len + strlen(name) + strlen(value) + 4); if (new_header == NULL) { ERROR_EXIT("内存分配失败"); } response->header = new_header; sprintf(response->header + header_len, "%s: %srn", name, value); } // 完成HTTP响应头 void http_response_finish_headers(HttpResponse* response) { char* new_header; int header_len = response->header ? strlen(response->header) : 0; new_header = realloc(response->header, header_len + 3); if (new_header == NULL) { ERROR_EXIT("内存分配失败"); } response->header = new_header; sprintf(response->header + header_len, "rn"); } // 设置HTTP响应体 void http_response_set_body(HttpResponse* response, const char* body, size_t length) { if (response->body != NULL) { free(response->body); } if (body != NULL && length > 0) { response->body = malloc(length); if (response->body == NULL) { ERROR_EXIT("内存分配失败"); } memcpy(response->body, body, length); response->body_length = length; } else { response->body = NULL; response->body_length = 0; } } // 发送HTTP响应 void http_response_send(HttpResponse* response, int socket) { if (response->header != NULL) { send(socket, response->header, strlen(response->header), 0); } if (response->body != NULL && response->body_length > 0) { send(socket, response->body, response->body_length, 0); } } // 读取文件内容 char* read_file(const char* filename, size_t* length) { FILE* file = fopen(filename, "rb"); if (file == NULL) { return NULL; } fseek(file, 0, SEEK_END); *length = ftell(file); fseek(file, 0, SEEK_SET); char* content = malloc(*length); if (content == NULL) { fclose(file); return NULL; } if (fread(content, 1, *length, file) != *length) { free(content); fclose(file); return NULL; } fclose(file); return content; } // 获取文件的MIME类型 const char* get_mime_type(const char* filename) { const char* dot = strrchr(filename, '.'); if (dot == NULL) { return "application/octet-stream"; } if (strcmp(dot, ".html") == 0 || strcmp(dot, ".htm") == 0) { return "text/html"; } else if (strcmp(dot, ".css") == 0) { return "text/css"; } else if (strcmp(dot, ".js") == 0) { return "application/javascript"; } else if (strcmp(dot, ".jpg") == 0 || strcmp(dot, ".jpeg") == 0) { return "image/jpeg"; } else if (strcmp(dot, ".png") == 0) { return "image/png"; } else if (strcmp(dot, ".gif") == 0) { return "image/gif"; } else if (strcmp(dot, ".txt") == 0) { return "text/plain"; } else { return "application/octet-stream"; } } // URL解码 void url_decode(char* dst, const char* src) { char a, b; while (*src) { if (*src == '%' && ((a = src[1]) && (b = src[2])) && (isxdigit(a) && isxdigit(b))) { if (a >= 'a') a -= 'a'-'A'; if (a >= 'A') a -= ('A' - 10); else a -= '0'; if (b >= 'a') b -= 'a'-'A'; if (b >= 'A') b -= ('A' - 10); else b -= '0'; *dst++ = 16 * a + b; src += 3; } else if (*src == '+') { *dst++ = ' '; src++; } else { *dst++ = *src++; } } *dst++ = ''; } // 处理HTTP请求 void handle_http_request(int client_socket, const char* request) { char method[16] = {0}; char path[256] = {0}; char protocol[16] = {0}; // 解析请求行 sscanf(request, "%15s %255s %15s", method, path, protocol); printf("请求方法: %sn", method); printf("请求路径: %sn", path); HttpResponse response; http_response_init(&response); // 只处理GET请求 if (strcmp(method, "GET") != 0) { http_response_set_status(&response, 501, "Not Implemented"); http_response_set_header(&response, "Content-Type", "text/plain"); http_response_set_header(&response, "Connection", "close"); http_response_finish_headers(&response); http_response_set_body(&response, "501 Not Implemented", strlen("501 Not Implemented")); http_response_send(&response, client_socket); http_response_free(&response); return; } // 解码URL char decoded_path[256]; url_decode(decoded_path, path); // 构建文件路径 char file_path[512]; if (strcmp(decoded_path, "/") == 0) { strcpy(file_path, "./index.html"); } else { // 跳过路径前导斜杠 snprintf(file_path, sizeof(file_path), ".%s", decoded_path); } // 读取文件 size_t file_length = 0; char* file_content = read_file(file_path, &file_length); if (file_content == NULL) { // 文件不存在 http_response_set_status(&response, 404, "Not Found"); http_response_set_header(&response, "Content-Type", "text/html"); http_response_set_header(&response, "Connection", "close"); http_response_finish_headers(&response); const char* not_found_content = "<html><body><h1>404 Not Found</h1><p>文件不存在</p></body></html>"; http_response_set_body(&response, not_found_content, strlen(not_found_content)); } else { // 文件存在 http_response_set_status(&response, 200, "OK"); http_response_set_header(&response, "Content-Type", get_mime_type(file_path)); http_response_set_header(&response, "Content-Length", file_content); http_response_set_header(&response, "Connection", "close"); http_response_finish_headers(&response); http_response_set_body(&response, file_content, file_length); free(file_content); } // 发送响应 http_response_send(&response, client_socket); http_response_free(&response); } // 客户端处理线程 void* client_handler(void* arg) { ThreadArgs* args = (ThreadArgs*)arg; int client_socket = args->client_socket; struct sockaddr_in client_address = args->client_address; free(args); char client_ip[INET_ADDRSTRLEN]; inet_ntop(AF_INET, &(client_address.sin_addr), client_ip, INET_ADDRSTRLEN); printf("客户端连接: %s:%dn", client_ip, ntohs(client_address.sin_port)); char buffer[BUFFER_SIZE] = {0}; int valread = read(client_socket, buffer, BUFFER_SIZE - 1); if (valread > 0) { printf("收到请求:n%sn", buffer); handle_http_request(client_socket, buffer); } printf("客户端断开连接: %s:%dn", client_ip, ntohs(client_address.sin_port)); close(client_socket); return NULL; } int main() { int server_fd; struct sockaddr_in address; int opt = 1; int addrlen = sizeof(address); // 创建套接字 if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == 0) { ERROR_EXIT("套接字创建失败"); } // 设置套接字选项 if (setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt, sizeof(opt))) { ERROR_EXIT("设置套接字选项失败"); } address.sin_family = AF_INET; address.sin_addr.s_addr = INADDR_ANY; address.sin_port = htons(PORT); // 绑定套接字 if (bind(server_fd, (struct sockaddr *)&address, sizeof(address)) < 0) { ERROR_EXIT("绑定失败"); } // 监听连接 if (listen(server_fd, 10) < 0) { ERROR_EXIT("监听失败"); } printf("银河麒麟操作系统Web服务器启动成功!n"); printf("监听端口: %dn", PORT); printf("访问地址: http://localhost:%dn", PORT); // 创建示例HTML文件 FILE* html_file = fopen("index.html", "w"); if (html_file != NULL) { fprintf(html_file, "<html>n"); fprintf(html_file, "<head>n"); fprintf(html_file, "<title>银河麒麟操作系统Web服务器</title>n"); fprintf(html_file, "<meta charset="UTF-8">n"); fprintf(html_file, "</head>n"); fprintf(html_file, "<body>n"); fprintf(html_file, "<h1>欢迎访问银河麒麟操作系统Web服务器!</h1>n"); fprintf(html_file, "<p>这是一个运行在银河麒麟操作系统上的简单Web服务器示例。</p>n"); fprintf(html_file, "</body>n"); fprintf(html_file, "</html>n"); fclose(html_file); } // 主循环，接受客户端连接 while (1) { int client_socket; struct sockaddr_in client_address; // 接受连接 if ((client_socket = accept(server_fd, (struct sockaddr *)&client_address, (socklen_t*)&addrlen)) < 0) { perror("接受连接失败"); continue; } // 创建线程参数 ThreadArgs* args = malloc(sizeof(ThreadArgs)); if (args == NULL) { perror("内存分配失败"); close(client_socket); continue; } args->client_socket = client_socket; args->client_address = client_address; // 创建线程处理客户端请求 pthread_t thread_id; if (pthread_create(&thread_id, NULL, client_handler, (void*)args) != 0) { perror("线程创建失败"); free(args); close(client_socket); continue; } // 分离线程，使其结束后自动释放资源 pthread_detach(thread_id); } // 关闭服务器套接字（实际上不会执行到这里） close(server_fd); return 0; }