第1周：C 语言系统编程强化

字数统计: 3.1k字   |   阅读时长≈ 16分

第1周：C 语言系统编程强化

目标：掌握系统级 C 编程的核心技术，为后续网络编程打下坚实基础。

1. 指针高级用法

1.1 函数指针

函数指针指向代码段中的函数入口地址，是 C 语言实现回调、动态调度的基础。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>

// 函数指针类型定义
typedef int (*BinaryOp)(int, int);

// 用函数指针实现的通用运算函数
int calculate(int a, int b, BinaryOp op) {
    return op(a, b);
}

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }
int mul(int a, int b) { return a * b; }

int main() {
    BinaryOp ops[] = {add, sub, mul};
    const char *names[] = {"add", "sub", "mul"};

    for (int i = 0; i < 3; i++) {
        printf("%s(3, 4) = %d\n", names[i], calculate(3, 4, ops[i]));
    }
    return 0;
}

典型应用场景：

场景 示例
排序比较函数 qsort 的 comparator
信号处理 signal(SIGINT, handler)
线程入口 pthread_create 的 start_routine
回调注册 epoll 事件回调、定时器回调

1.2 多级指针

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
#include <stdio.h>
#include <stdlib.h>

int main() {
    int x = 42;

    int *p = &x;      // p 指向 x
    int **pp = &p;    // pp 指向 p
    int ***ppp = &pp; // ppp 指向 pp

    printf("x = %d\n", x);       // 42
    printf("*p = %d\n", *p);     // 42
    printf("**pp = %d\n", **pp); // 42
    printf("***ppp = %d\n", ***ppp); // 42

    // 修改值
    **pp = 100;
    printf("x = %d\n", x); // 100

    // 动态二维数组
    int rows = 3, cols = 4;
    int **matrix = malloc(rows * sizeof(int *));
    for (int i = 0; i < rows; i++) {
        matrix[i] = malloc(cols * sizeof(int));
    }

    // 填充
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = i * cols + j;
        }
    }

    printf("matrix[2][3] = %d\n", matrix[2][3]); // 11

    // 释放（注意顺序！）
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);

    return 0;
}

1.3 指针与数组的等价与差异

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
#include <stdio.h>

int main() {
    int arr[5] = {10, 20, 30, 40, 50};
    int *p = arr;  // arr 退化为指向首元素的指针

    // 以下访问方式等价
    printf("arr[2] = %d\n", arr[2]);      // 30
    printf("*(arr+2) = %d\n", *(arr+2)); // 30
    printf("p[2] = %d\n", p[2]);         // 30
    printf("*(p+2) = %d\n", *(p+2));    // 30

    // === 关键差异 ===

    // 1. sizeof
    printf("sizeof(arr) = %zu\n", sizeof(arr));   // 20 (5 * 4)
    printf("sizeof(p) = %zu\n", sizeof(p));        // 8 (指针大小，64位)

    // 2. & 取地址
    printf("&arr = %p\n", (void *)&arr);   // 数组整体地址
    printf("p = %p\n", (void *)p);          // 首元素地址（值相同）
    printf("&arr+1 = %p\n", (void *)(&arr + 1)); // +20（跳过整个数组）
    printf("p+1 = %p\n", (void *)(p + 1));   // +4（跳一个元素）

    // 3. 赋值
    // p = NULL;     // ✅ 可以
    // arr = NULL;   // ❌ 编译错误！数组名是常量指针

    return 0;
}

核心要点：

  • 大多数情况下 arr 和 &arr[0] 值相同，但类型不同
  • sizeof(arr) 在函数参数中会失效（数组退化为指针）
  • 数组名不能被赋值，指针可以

2. 动态内存管理

2.1 malloc / calloc / realloc / free 详解

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main() {
    // === malloc：分配未初始化内存 ===
    int *p1 = malloc(10 * sizeof(int));
    if (!p1) { perror("malloc"); exit(1); }
    // p1 的内容是垃圾值

    // === calloc：分配并清零 ===
    int *p2 = calloc(10, sizeof(int));
    if (!p2) { perror("calloc"); exit(1); }
    // p2 的所有元素都是 0

    // 验证
    printf("p2[0] = %d (should be 0)\n", p2[0]);

    // === realloc：调整大小 ===
    p1 = realloc(p1, 20 * sizeof(int));
    if (!p1) { perror("realloc"); exit(1); }
    // 原有数据保留（如果原地扩展），新区域未初始化

    // === 安全的 realloc 用法 ===
    int *tmp = realloc(p1, 30 * sizeof(int));
    if (!tmp) {
        // p1 仍然有效，不要泄露
        perror("realloc");
        free(p1);
        exit(1);
    }
    p1 = tmp;

    free(p1);
    free(p2);

    return 0;
}

2.2 内存对齐

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
#include <stdio.h>

struct Example1 {
    char c;     // 1 byte
    // padding: 3 bytes（对齐到 int）
    int x;      // 4 bytes
    char d;     // 1 byte
    // padding: 3 bytes（对齐到 struct 大小）
};
// sizeof = 12

struct Example2 {
    int x;      // 4 bytes
    char c;     // 1 byte
    char d;     // 1 byte
    // padding: 2 bytes
};
// sizeof = 8

// 强制 packed（GCC 扩展）
struct __attribute__((packed)) Packed {
    char c;
    int x;
};
// sizeof = 5（无填充，但访问可能低效）

int main() {
    printf("Example1: %zu bytes\n", sizeof(struct Example1)); // 12
    printf("Example2: %zu bytes\n", sizeof(struct Example2)); // 8

    // alignof (C11)
    printf("alignof(int): %zu\n", _Alignof(int));   // 4
    printf("alignof(double): %zu\n", _Alignof(double)); // 8

    return 0;
}

对齐规则：

  • 每个成员按自身对齐要求放置（通常是其大小的幂次）
  • struct 整体大小按最大成员对齐
  • #pragma pack 或 __attribute__((packed)) 可修改，但可能影响性能

2.3 字节序（Endianness）

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
#include <stdio.h>
#include <stdint.h>
#include <arpa/inet.h>  // htonl, ntohl, htons, ntohs

// 手动实现字节序转换（理解原理）
uint32_t my_htonl(uint32_t hostlong) {
    return ((hostlong & 0xFF) << 24) |
           ((hostlong & 0xFF00) << 8) |
           ((hostlong >> 8) & 0xFF00) |
           ((hostlong >> 24) & 0xFF);
}

int main() {
    // 主机字节序（小端）
    uint32_t x = 0x12345678;
    unsigned char *bytes = (unsigned char *)&x;
    printf("Host order: %02X %02X %02X %02X\n",
           bytes[0], bytes[1], bytes[2], bytes[3]);
    // 小端机器输出: 78 56 34 12
    // 大端机器输出: 12 34 56 78

    // 网络字节序（大端，Big Endian）
    uint32_t net = htonl(x);
    unsigned char *net_bytes = (unsigned char *)&net;
    printf("Network order: %02X %02X %02X %02X\n",
           net_bytes[0], net_bytes[1], net_bytes[2], net_bytes[3]);
    // 任何机器输出: 12 34 56 78

    // 短整型转换
    uint16_t port = 8080;
    uint16_t net_port = htons(port);

    printf("Port %d -> network: 0x%04X\n", port, net_port);

    return 0;
}

网络字节序规则：

  • 网络传输统一使用 大端序（Big Endian，Network Byte Order）
  • 主机可能是大端或小端，发送前转 hton*，接收后转 ntoh*
  • h = host, n = network, s = short (16bit), l = long (32bit)

2.4 位运算实战

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
#include <stdio.h>
#include <stdbool.h>

// 判断是否为 2 的幂
bool is_power_of_two(unsigned int n) {
    return n > 0 && (n & (n - 1)) == 0;
}

// 获取最低位的 1
unsigned int lowest_bit(unsigned int n) {
    return n & (-n);
}

// 位掩码操作
#define FLAG_READ   0x01  // 0001
#define FLAG_WRITE  0x02  // 0010
#define FLAG_EXEC   0x04  // 0100
#define FLAG_HIDDEN 0x08  // 1000

int main() {
    unsigned int flags = FLAG_READ | FLAG_WRITE; // 0011

    // 检查标志
    printf("Has READ: %d\n", !!(flags & FLAG_READ));   // 1
    printf("Has EXEC: %d\n", !!(flags & FLAG_EXEC));   // 0

    // 设置标志
    flags |= FLAG_HIDDEN;  // 添加 HIDDEN

    // 清除标志
    flags &= ~FLAG_WRITE;  // 移除 WRITE

    // 切换标志
    flags ^= FLAG_EXEC;    // 翻转 EXEC

    printf("Flags: 0x%X\n", flags); // 0x0D = 00001101

    printf("is_power_of_two(16): %d\n", is_power_of_two(16)); // 1
    printf("is_power_of_two(15): %d\n", is_power_of_two(15)); // 0
    printf("lowest_bit(0x34): 0x%X\n", lowest_bit(0x34));     // 0x04

    // 位域（struct bit-field）
    struct Bits {
        unsigned int flag1 : 1;  // 1 bit
        unsigned int flag2 : 1;
        unsigned int value : 4;  // 4 bits (0-15)
        unsigned int reserved : 26;
    };

    struct Bits b = {1, 0, 7, 0};
    printf("flag1=%d value=%d\n", b.flag1, b.value); // flag1=1 value=7

    return 0;
}

2.5 字节流缓冲区实现

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
// buffer.h
#ifndef BUFFER_H
#define BUFFER_H

#include <stddef.h>
#include <stdint.h>

typedef struct {
    uint8_t *data;      // 缓冲区数据
    size_t capacity;    // 总容量
    size_t read_pos;    // 读指针位置
    size_t write_pos;   // 写指针位置
} ByteBuffer;

// 创建缓冲区
ByteBuffer *buf_create(size_t initial_capacity);

// 销毁缓冲区
void buf_free(ByteBuffer *buf);

// 写入数据
int buf_write(ByteBuffer *buf, const void *data, size_t len);

// 读取数据
int buf_read(ByteBuffer *buf, void *out, size_t len);

// 查找分隔符（如 \r\n）
ssize_t buf_find(ByteBuffer *buf, const char *delim, size_t delim_len);

// 可读字节数
static inline size_t buf_readable(const ByteBuffer *buf) {
    return buf->write_pos - buf->read_pos;
}

// 可写字节数
static inline size_t buf_writable(const ByteBuffer *buf) {
    return buf->capacity - buf->write_pos;
}

#endif
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
// buffer.c
#include "buffer.h"
#include <stdlib.h>
#include <string.h>

#define DEFAULT_CAPACITY 1024

ByteBuffer *buf_create(size_t initial_capacity) {
    ByteBuffer *buf = malloc(sizeof(ByteBuffer));
    if (!buf) return NULL;

    buf->capacity = initial_capacity > 0 ? initial_capacity : DEFAULT_CAPACITY;
    buf->data = malloc(buf->capacity);
    buf->read_pos = 0;
    buf->write_pos = 0;

    if (!buf->data) { free(buf); return NULL; }
    return buf;
}

void buf_free(ByteBuffer *buf) {
    if (buf) {
        free(buf->data);
        free(buf);
    }
}

// 确保有足够的写空间
static int buf_ensure_capacity(ByteBuffer *buf, size_t extra) {
    size_t needed = buf->write_pos + extra;
    if (needed <= buf->capacity) return 0;

    // 扩容策略：按 1.5 倍或足够容纳增长
    size_t new_cap = buf->capacity * 3 / 2;
    if (new_cap < needed) new_cap = needed;

    uint8_t *new_data = realloc(buf->data, new_cap);
    if (!new_data) return -1;

    buf->data = new_data;
    buf->capacity = new_cap;
    return 0;
}

int buf_write(ByteBuffer *buf, const void *data, size_t len) {
    if (buf_ensure_capacity(buf, len) != 0) return -1;

    memcpy(buf->data + buf->write_pos, data, len);
    buf->write_pos += len;
    return 0;
}

int buf_read(ByteBuffer *buf, void *out, size_t len) {
    if (buf_readable(buf) < len) return -1;  // 数据不足

    memcpy(out, buf->data + buf->read_pos, len);
    buf->read_pos += len;

    // 如果读指针超过一半且读写指针差距大，compact
    if (buf->read_pos > buf->capacity / 2 &&
        buf_readable(buf) < buf->capacity / 2) {
        size_t readable = buf_readable(buf);
        memmove(buf->data, buf->data + buf->read_pos, readable);
        buf->read_pos = 0;
        buf->write_pos = readable;
    }

    return 0;
}

ssize_t buf_find(ByteBuffer *buf, const char *delim, size_t delim_len) {
    if (buf_readable(buf) < delim_len) return -1;

    size_t search_end = buf->write_pos - delim_len + 1;
    for (size_t i = buf->read_pos; i < search_end; i++) {
        if (memcmp(buf->data + i, delim, delim_len) == 0) {
            return (ssize_t)(i - buf->read_pos);  // 相对读指针的偏移
        }
    }
    return -1;  // 未找到
}
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
// buffer_test.c
#include "buffer.h"
#include <stdio.h>
#include <string.h>

int main() {
    ByteBuffer *buf = buf_create(0);

    // 测试写入
    buf_write(buf, "Hello", 5);
    buf_write(buf, " ", 1);
    buf_write(buf, "World", 5);

    printf("Readable: %zu bytes\n", buf_readable(buf)); // 11
    printf("Writable: %zu bytes\n", buf_writable(buf)); // 1013

    // 测试读取
    char out[20];
    buf_read(buf, out, 5);
    out[5] = '\0';
    printf("Read: '%s'\n", out); // "Hello"

    // 测试查找
    buf_write(buf, "\r\n", 2);  // 添加分隔符
    ssize_t pos = buf_find(buf, "\r\n", 2);
    printf("Found \\r\\n at offset: %zd\n", pos); // 6

    buf_free(buf);
    return 0;
}

3. 系统调用错误处理

3.1 错误处理宏封装

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
// syscall_wrapper.h
#ifndef SYSCALL_WRAPPER_H
#define SYSCALL_WRAPPER_H

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

// 系统调用错误检查宏
#define CHECK(expr, msg) do { \
    if (!(expr)) { \
        fprintf(stderr, "[ERROR] %s:%d: %s: %s\n", \
                __FILE__, __LINE__, msg, strerror(errno)); \
        exit(EXIT_FAILURE); \
    } \
} while(0)

#define CHECK_NULL(expr, msg) CHECK((expr) != NULL, msg)
#define CHECK_POSITIVE(expr, msg) CHECK((expr) > 0, msg)
#define CHECK_ZERO(expr, msg) CHECK((expr) == 0, msg)

// 带错误码返回的版本（不退出）
#define TRY(expr) ({ \
    long __ret = (long)(expr); \
    if (__ret < 0) { \
        fprintf(stderr, "[ERROR] %s:%d: %s: %s\n", \
                __FILE__, __LINE__, #expr, strerror(errno)); \
    } \
    __ret; \
})

#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// syscall_demo.c
#include "syscall_wrapper.h"
#include <fcntl.h>
#include <unistd.h>

int main() {
    // 打开文件
    int fd = open("test.txt", O_RDONLY);
    CHECK(fd >= 0, "open test.txt");

    // 读取
    char buf[256];
    ssize_t n = read(fd, buf, sizeof(buf));
    CHECK_POSITIVE(n, "read failed");

    close(fd);

    // malloc 检查
    char *p = malloc(1024);
    CHECK_NULL(p, "malloc");

    free(p);
    return 0;
}

3.2 Valgrind 内存检测

1
2
3
4
5
6
7
8
9
10
# 编译时加调试信息
gcc -g -o program program.c

# 使用 Valgrind 检测
valgrind --leak-check=full --show-leak-kinds=all ./program

# 常见输出解读：
# ==12345== 40 bytes in 1 blocks definitely lost（内存泄漏）
# ==12345== Invalid read of size 4（非法读取）
# ==12345== Conditional jump or move depends on uninitialised value(s)（使用未初始化值）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// valgrind_demo.c
#include <stdlib.h>
#include <string.h>

// ❌ 内存泄漏示例
void leak_example() {
    char *p = malloc(100);
    strcpy(p, "leaked memory");
    // 忘记 free — 函数返回后指针丢失
}

// ✅ 正确示例
void no_leak() {
    char *p = malloc(100);
    strcpy(p, "properly freed");
    free(p);
}

int main() {
    leak_example();
    no_leak();
    return 0;
}
1
2
3
4
5
6
7
8
$ valgrind --leak-check=full ./valgrind_demo
==12345== HEAP SUMMARY:
==12345==     in use at exit: 40 bytes in 1 blocks
==12345==   total heap usage: 2 allocs, 1 frees, 1,064 bytes allocated
==12345==
==12345== 40 bytes in 1 blocks are definitely lost in loss record 1 of 1
==12345==    at 0x4848899: malloc (in /usr/lib/x86_64-linux-gnu/valgrind/...)
==12345==    by 0x...: leak_example (valgrind_demo.c:8)

3.3 实践：字节流缓冲区完整测试

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
// buffer_advanced.c
#include "buffer.h"
#include <stdio.h>
#include <string.h>

// 模拟 TCP 粘包场景
int main() {
    ByteBuffer *buf = buf_create(0);

    printf("=== 测试 1: 基本读写 ===\n");
    buf_write(buf, "ABCDEFGHIJ", 10);
    char chunk[5];
    buf_read(buf, chunk, 5);
    chunk[5] = '\0';
    printf("First read: %s\n", chunk); // "ABCDE"

    buf_read(buf, chunk, 5);
    chunk[5] = '\0';
    printf("Second read: %s\n", chunk); // "FGHIJ"

    printf("Readable: %zu (expect 0)\n", buf_readable(buf));

    printf("\n=== 测试 2: 动态扩容 ===\n");
    buf_free(buf);
    buf = buf_create(10);  // 小容量

    // 写入超过初始容量的数据
    char big_data[100];
    memset(big_data, 'X', sizeof(big_data));
    buf_write(buf, big_data, sizeof(big_data));
    printf("Written 100 bytes, capacity should be >= 100: %zu\n", buf->capacity);

    printf("\n=== 测试 3: TCP 粘包解析（HTTP 请求）=== \n");
    buf_free(buf);
    buf = buf_create(0);

    // 模拟分两次到达的 HTTP 请求
    buf_write(buf, "GET /index HTTP/1.1\r\nHost: localhost\r\n", 37);
    buf_write(buf, "User-Agent: curl\r\n\r\n", 21);

    // 查找完整请求
    ssize_t pos = buf_find(buf, "\r\n\r\n", 4);
    printf("Found HTTP header end at offset: %zd\n", pos);

    if (pos >= 0) {
        char header[100];
        buf_read(buf, header, pos + 4);
        header[pos + 4] = '\0';
        printf("--- HTTP Request ---\n%s\n", header);
    }

    printf("\n=== 测试 4: 空分隔查找 ===\n");
    buf_free(buf);
    buf = buf_create(0);

    buf_write(buf, "a,b,c,d,e", 9);
    ssize_t comma = buf_find(buf, ",", 1);
    printf("First comma at: %zd\n", comma); // 1

    buf_read(buf, chunk, 1);  // 读掉 'a'
    comma = buf_find(buf, ",", 1);
    printf("Next comma at: %zd\n", comma); // 1 (now at 'b')

    buf_free(buf);
    return 0;
}
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Linux开发、
公众号开发、开源爱好者、Linux

联系QQ:562054870