C语言字符串处理与结构体实战技巧

胖葫芦

1. C语言字符串处理与结构体实战指南

作为一门接近硬件底层的编程语言，C语言对字符串和结构体的处理方式与其他高级语言有着显著区别。本文将深入解析strtok字符串切割、sprintf/sscanf格式化处理以及结构体的核心用法，这些都是C语言开发中的必备技能。

2. 字符串切割函数strtok深度解析

2.1 strtok基础用法

strtok是C标准库中最常用的字符串切割函数，其函数原型为：

c复制char *strtok(char *str, const char *delim);

这个函数的工作原理是通过修改原始字符串，将分隔符替换为'\0'字符来实现切割。使用时需要注意：

第一次调用时，str参数需要传入待切割字符串的地址
后续调用时，str参数必须设为NULL
每次调用返回当前切割出的子字符串首地址
切割完成后返回NULL

重要提示：strtok会直接修改原始字符串内容，因此不能用于字符串常量。如果需要对常量字符串进行切割，需要先复制到可修改的内存中。

2.2 strtok实战案例

下面是一个完整的strtok使用示例，展示了如何将包含多个分隔符的字符串切割并存储：

c复制#include <stdio.h>
#include <string.h>

void tokenize_string() {
    char text[] = "name:age:city:occupation";
    char *tokens[10] = {NULL};  // 存储切割结果
    int i = 0;
    
    // 第一次切割
    tokens[i] = strtok(text, ":");
    
    // 后续切割
    while(tokens[i] != NULL) {
        i++;
        tokens[i] = strtok(NULL, ":");
    }
    
    // 输出结果
    for(int j=0; j<i; j++) {
        printf("Token %d: %s\n", j, tokens[j]);
    }
}

int main() {
    tokenize_string();
    return 0;
}

这段代码的输出将是：

code复制Token 0: name
Token 1: age
Token 2: city
Token 3: occupation

2.3 strtok高级技巧

多分隔符处理：可以一次指定多个分隔符，如":,#@"等
连续分隔符：strtok会自动跳过连续的分隔符
线程安全版本：考虑使用strtok_r（POSIX标准）实现线程安全

实际开发中，建议封装自己的字符串切割函数，避免直接使用strtok带来的副作用。

3. 格式化字符串处理：sprintf与sscanf

3.1 sprintf格式化输出

sprintf函数原型：

c复制int sprintf(char *str, const char *format, ...);

它可以将各种类型的数据格式化为字符串，存储到指定的缓冲区中。常见用途包括：

数字转字符串
组合多个变量为格式化字符串
生成特定格式的报文

3.1.1 基础用法示例

c复制char buffer[100];
int year = 2023, month = 12, day = 31;
int len = sprintf(buffer, "%d-%02d-%02d", year, month, day);
// buffer内容为"2023-12-31"，len为10

3.1.2 安全注意事项

必须确保目标缓冲区足够大
考虑使用snprintf替代，指定最大写入长度
格式化字符串要严格匹配参数类型

3.2 sscanf格式化输入

sscanf函数原型：

c复制int sscanf(const char *str, const char *format, ...);

它可以从字符串中按照指定格式提取数据，是字符串解析的利器。

3.2.1 基础用法

c复制char date[] = "2023-12-31";
int y, m, d;
sscanf(date, "%d-%d-%d", &y, &m, &d);
// y=2023, m=12, d=31

3.2.2 高级特性

跳过字段：使用%*格式说明符

c复制sscanf("123 abc 456", "%*d %s %d", str, &num); // 跳过第一个数字

指定宽度：%[width]格式

c复制char str[10];
sscanf("1234567890", "%5s", str); // 只取前5个字符

字符集合：%[a-z]提取小写字母，%[^0-9]提取非数字字符

c复制char letters[20];
sscanf("abc123def", "%[a-z]", letters); // letters="abc"

3.2.3 实际应用案例

解析电子邮件地址：

c复制char email[] = "user@example.com";
char name[50], domain[50];
sscanf(email, "%[^@]@%[^.]", name, domain);
// name="user", domain="example"

4. const关键字的深度理解

4.1 const修饰变量

const修饰的变量成为只读变量，必须在定义时初始化：

c复制const int MAX_SIZE = 100;
// MAX_SIZE = 200;  // 编译错误

4.2 const与指针的组合

const与指针结合使用时，位置不同含义不同：

*const int p：指向常量的指针

c复制int a = 10;
const int *p = &a;
// *p = 20;  // 错误：不能通过p修改a的值
a = 20;     // 合法：可以直接修改a
p = &b;     // 合法：可以改变p的指向

int * const p：常量指针

c复制int a = 10, b = 20;
int * const p = &a;
*p = 30;    // 合法：可以修改指向的值
// p = &b;  // 错误：不能改变p的指向

const int * const p：指向常量的常量指针

c复制const int * const p = &a;
// *p = 30;  // 错误
// p = &b;   // 错误

实际开发中，合理使用const可以提高代码安全性和可读性，特别是在函数参数传递时。

5. 结构体全面解析

5.1 结构体定义与内存布局

结构体定义语法：

c复制struct 结构体名 {
    类型 成员1;
    类型 成员2;
    // ...
};

示例：

c复制struct Student {
    int id;
    char name[20];
    float score;
};

内存布局特点：

成员在内存中按定义顺序排列
可能存在内存对齐导致的填充字节
可以使用sizeof获取结构体总大小

5.2 结构体变量操作

5.2.1 初始化方式

定义时初始化：

c复制struct Student s1 = {1001, "张三", 90.5};

指定成员初始化（C99起）：

c复制struct Student s2 = {.name="李四", .id=1002};

逐个成员赋值：

c复制struct Student s3;
s3.id = 1003;
strcpy(s3.name, "王五");
s3.score = 85.0;

5.2.2 结构体赋值

结构体变量可以直接相互赋值（浅拷贝）：

c复制struct Student s4 = s1;  // 复制s1的所有成员值到s4

对于包含指针成员的结构体，需要注意深拷贝问题。

5.3 结构体数组

定义和初始化结构体数组：

c复制struct Student class[3] = {
    {1001, "张三", 90.5},
    {1002, "李四", 85.0},
    {1003, "王五", 92.0}
};

遍历结构体数组：

c复制for(int i=0; i<3; i++) {
    printf("学号：%d，姓名：%s，成绩：%.1f\n",
           class[i].id, class[i].name, class[i].score);
}

5.4 结构体使用技巧

使用typedef简化：

c复制typedef struct {
    int x;
    int y;
} Point;

Point p1;  // 无需写struct关键字

结构体嵌套：

c复制struct Date {
    int year, month, day;
};

struct Employee {
    int id;
    char name[20];
    struct Date hire_date;
};

结构体作为函数参数：

c复制void printStudent(struct Student s) {
    // 传值调用，会复制整个结构体
}

void modifyStudent(struct Student *ps) {
    // 传指针，可以修改原结构体
}

6. 综合实战：学生信息管理系统

下面是一个完整的学生信息管理示例，综合运用了字符串处理和结构体：

c复制#include <stdio.h>
#include <string.h>

#define MAX_STUDENTS 50

typedef struct {
    int id;
    char name[20];
    float score;
} Student;

void inputStudents(Student arr[], int n) {
    for(int i=0; i<n; i++) {
        printf("输入第%d个学生信息(学号 姓名 成绩): ", i+1);
        scanf("%d %s %f", &arr[i].id, arr[i].name, &arr[i].score);
    }
}

void printStudents(Student arr[], int n) {
    printf("\n学生列表：\n");
    printf("学号\t姓名\t成绩\n");
    for(int i=0; i<n; i++) {
        printf("%d\t%s\t%.1f\n", arr[i].id, arr[i].name, arr[i].score);
    }
}

float averageScore(Student arr[], int n) {
    float sum = 0;
    for(int i=0; i<n; i++) {
        sum += arr[i].score;
    }
    return sum / n;
}

int main() {
    Student class[MAX_STUDENTS];
    int count;
    
    printf("输入学生人数：");
    scanf("%d", &count);
    
    inputStudents(class, count);
    printStudents(class, count);
    
    float avg = averageScore(class, count);
    printf("\n平均成绩：%.2f\n", avg);
    
    return 0;
}

这个示例展示了：

使用typedef定义结构体类型
结构体数组的输入输出
结构体作为函数参数传递
基于结构体的数据统计

7. 常见问题与解决方案

7.1 strtok使用陷阱

问题：多次调用strtok时出现异常
原因：没有正确处理NULL参数或跨线程调用
解决：

确保后续调用第一个参数为NULL
考虑使用strtok_r（可重入版本）
封装自己的字符串分割函数

7.2 sscanf格式匹配错误

问题：sscanf返回值与预期不符
原因：格式字符串与实际输入不匹配
解决：

检查sscanf返回值（成功匹配的参数个数）
使用%n获取已处理的字符数
添加格式验证，如：

c复制if(sscanf(input, "%d", &num) != 1) {
    printf("输入格式错误\n");
}

7.3 结构体内存对齐问题

问题：结构体大小与预期不符
原因：编译器进行了内存对齐优化
解决：

使用#pragma pack调整对齐方式
重新排列成员顺序（从大到小）
显式添加填充字节

7.4 结构体包含指针成员

问题：结构体赋值后指针成员指向同一内存
解决：

实现深拷贝函数
为指针成员单独分配内存
考虑使用柔性数组（C99）

8. 性能优化建议

字符串处理：
- 避免频繁使用strtok切割大字符串
- 对于固定格式解析，考虑手写解析函数
- 使用memcpy代替strcpy处理已知长度的字符串
结构体使用：
- 按成员类型大小降序排列，减少填充字节
- 频繁传递的结构体使用指针而非值传递
- 考虑使用结构体数组而非链表提高缓存命中率
内存管理：
- 为结构体中的指针成员实现正确的拷贝构造函数
- 使用内存池管理大量小结构体
- 释放结构体前先释放其内部的动态分配资源