C语言字符串拆分函数详解及应用369

在C语言编程中，经常需要将一个字符串按照某种规则拆分成多个子字符串。例如，解析CSV文件、处理命令行参数、提取网页数据等场景都涉及到字符串的拆分。然而，C语言标准库并没有提供一个直接的字符串拆分函数，需要程序员自己编写或使用第三方库函数来实现。本文将深入探讨C语言字符串拆分函数的实现方法、常用技巧以及实际应用案例，帮助读者掌握这项重要的编程技能。

C语言字符串处理主要依赖于标准库中的字符串函数，例如strcpy, strcat, strlen, strstr等。但是这些函数并不能直接完成字符串的拆分。我们需要利用这些函数来构建自己的字符串拆分函数。常用的拆分方式包括按照指定字符拆分、按照指定字符串拆分以及按照指定长度拆分。

一、按照指定字符拆分

这是最常见的字符串拆分方式，例如将一个以逗号分隔的字符串拆分成多个子字符串。以下是一个按照指定字符拆分的函数示例：```c
#include
#include
#include
char splitString(const char* str, char delimiter, int* count) {
*count = 0;
char* token;
char tokens = NULL;
token = strtok((char*)str, &delimiter); // 第一次调用strtok需要传入字符串本身
while (token != NULL) {
(*count)++;
tokens = (char)realloc(tokens, (*count) * sizeof(char*));
if (tokens == NULL) {
fprintf(stderr, "内存分配失败");
return NULL;
}
tokens[*count - 1] = strdup(token); //strdup复制字符串，避免修改原字符串
token = strtok(NULL, &delimiter);
}
return tokens;
}
int main() {
char str[] = "apple,banana,orange";
int count;
char tokens = splitString(str, ',', &count);
if (tokens != NULL) {
for (int i = 0; i < count; i++) {
printf("Token %d: %s", i + 1, tokens[i]);
free(tokens[i]); //释放分配的内存
}
free(tokens); //释放tokens数组的内存
}
return 0;
}
```

此函数使用了strtok函数，它会修改原始字符串，因此需要小心处理。我们使用了strdup函数来复制每个子字符串，避免修改原始字符串，并在最后释放分配的内存，避免内存泄漏。 realloc函数用于动态调整数组大小，以适应不同数量的子字符串。

二、按照指定字符串拆分

如果需要按照一个字符串而不是单个字符进行拆分，则需要使用strstr函数来查找子字符串，然后进行分割。以下是一个示例：```c
#include
#include
#include
char splitStringByString(const char* str, const char* delimiter, int* count) {
*count = 0;
char* token;
char tokens = NULL;
char* str_copy = strdup(str); // 复制字符串，避免修改原字符串
char* pos = str_copy;
while ((token = strstr(pos, delimiter)) != NULL) {
(*count)++;
tokens = (char)realloc(tokens, (*count) * sizeof(char*));
if (tokens == NULL) {
fprintf(stderr, "内存分配失败");
free(str_copy);
return NULL;
}
tokens[*count - 1] = (char*)malloc((token - pos + 1) * sizeof(char));
strncpy(tokens[*count - 1], pos, token - pos);
tokens[*count - 1][token - pos] = '\0';
pos = token + strlen(delimiter);
}
(*count)++;
tokens = (char)realloc(tokens, (*count) * sizeof(char*));
if (tokens == NULL) {
fprintf(stderr, "内存分配失败");
free(str_copy);
return NULL;
}
tokens[*count - 1] = strdup(pos);
free(str_copy);
return tokens;
}

int main() {
char str[] = "apple-banana-orange";
int count;
char tokens = splitStringByString(str, "-banana-", &count);
if (tokens != NULL) {
for (int i = 0; i < count; i++) {
printf("Token %d: %s", i + 1, tokens[i]);
free(tokens[i]);
}
free(tokens);
}
return 0;
}
```

这个函数首先复制了原始字符串，避免修改原字符串。然后使用`strstr`函数查找分隔符，并用`strncpy`复制子字符串，最后释放分配的内存，避免内存泄漏。需要注意的是，这个函数的处理逻辑比按字符分割更加复杂。

三、按照指定长度拆分

有时需要按照指定的长度将字符串拆分成多个子字符串。以下是一个示例：```c
#include
#include
#include
char splitStringByLength(const char* str, int length, int* count) {
int strLen = strlen(str);
*count = (strLen + length - 1) / length;
char tokens = (char)malloc(*count * sizeof(char*));
if (tokens == NULL) {
fprintf(stderr, "内存分配失败");
return NULL;
}
for (int i = 0; i < *count; i++) {
int start = i * length;
int end = (i + 1) * length;
if (end > strLen) {
end = strLen;
}
tokens[i] = (char*)malloc((end - start + 1) * sizeof(char));
if (tokens[i] == NULL) {
fprintf(stderr, "内存分配失败");
for (int j = 0; j < i; j++) {
free(tokens[j]);
}
free(tokens);
return NULL;
}
strncpy(tokens[i], str + start, end - start);
tokens[i][end - start] = '\0';
}
return tokens;
}
int main() {
char str[] = "Thisisalongstring";
int count;
char tokens = splitStringByLength(str, 5, &count);
if (tokens != NULL) {
for (int i = 0; i < count; i++) {
printf("Token %d: %s", i + 1, tokens[i]);
free(tokens[i]);
}
free(tokens);
}
return 0;
}
```