开源-C-字符串切割

字符串切割

简介

​ 在实际进行C相关的开源库使用中，无论是更改还是想要预期的输入，发现没有比较满意的字符串切割库，而且C原生的字符串切割函数也不太满足使用场景，有点过于简单，所以后期开发的了一个简单的字符串切割库，满足的工作的使用。

思路

​ 在实际的使用场景中，主要是对下标进行访问，所以有几个关键点，

1.切割后的子字符串完整
2.切割后的子字符串有序

在满足上诉两个要求后，就要考虑分割符的个数，是否支持动态扩张，是否支持多种分割符。所以理出了如下思路，

1.完整 - 遍历
2.有序 - 数组保存
3.动态扩张 - 链表
4.多种分隔符 - 合并

然后后续就开始介绍源码。

关键代码

数据结构

//字符串子串
struct _StringSplitItem
{
    int pos;
    int size;
    int length;
    char* str;
};
typedef struct _StringSplitItem StringSplitItem;

//字符串
struct _StringSplit
{
    int number;
    int size;
    StringSplitItem** items;
};
typedef struct _StringSplit StringSplit;

字符串分割步骤如下：

1.获取分割符数量
2.解析子串个数
3.计算存储空间大小，创建对应空间结构
4.存储数据
5.打印测试，取用

入口函数-分割处理

/**
 * @name: 字符串分割处理
 * @msg: 
 * @param {char} delim 分隔符
 * @param {char} *src 字符串输入源
 * @return {*} 分隔符结构体
 */
StringSplit* string_split_handle(char delim, char *src)
{
    //获取分割符数量
    int delim_number = get_delim_number(src, delim);
    //计算子串个数 - 如果字符串末尾为分隔符，则子串数量为 分隔符数量，如果末尾还有数量则子串数量为 分隔符数量+1
    int sub_str_number = (delimnumber_end->value - 1 == (strlen(src) - 1 )) ? delim_number : delim_number + 1;
    #ifdef RUN_DEBUG
        printf("delim_number:%d, sub_str_number:%d\n", delim_number, sub_str_number);
    #endif
    //计算输入字符串大小
    int length = strlen(src);
    //计算总的数据结构大小 
    int size = length - delim_number + 2 * sizeof(int) + 3 * sub_str_number * sizeof(int);
    //开辟存储空间
    StringSplit* string_split = (StringSplit*)malloc(sizeof(StringSplit));
    string_split->size = size;
    string_split->number = sub_str_number;
    string_split->items = calloc(sub_str_number, sizeof(StringSplitItem*));
    //遍历赋值
    delimnumber_next = delimnumber_head;
    for(int i = 0; i < sub_str_number; i++)
    {
        string_split->items[i] = (StringSplitItem*)malloc(sizeof(StringSplitItem));
        StringSplitItem* item = string_split->items[i];
        item->pos = delimnumber_next->value;
        item->length = (i + 1 == sub_str_number) ? length - item->pos : delimnumber_next->next->value - delimnumber_next->value - 1;
        item->size = 3 * sizeof(int) + item->length;
        item->str = calloc((size_t)item->length + 1, sizeof(char));
        memset(item->str, 0, item->length + 1);
        memcpy(item->str, src + item->pos, item->length);
        #ifdef RUN_DEBUG
            printf("index:%d, pos:%d, length:%d, size:%d, str:%s\n", i, item->pos, item->length, item->size, item->str);
        #endif
        delimnumber_next_value();
    }
    #ifdef RUN_DEBUG
        printf("Ending Split\n");
    #endif
    return  string_split;
}

获取字符串分割符数量

/**
 * @name: 获取字符串分隔符数量
 * @msg: 
 * @param {char*} src_strings 字符串输入源
 * @param {char} delim 分隔符
 * @param {int} *pos 分隔符位置值
 * @return {*} 分隔符数量
 */
static int get_delim_number(char* src_strings, char delim)
{
    int delim_number = 0, i = 0;
    delimnumber_expand(i);
    while((*src_strings) && (*src_strings) != '\0')
    {
        if(*src_strings == delim)
        {
            delim_number++;
            delimnumber_expand(i + 1);
        }
        i++;
        src_strings++;
    }
    return delim_number;
}

/**
 * @name: 获取字符串分隔符数量
 * @msg: 
 * @param {char*} src_strings 字符串输入源
 * @param {char*} delims 分隔符
 * @param {int} *pos 分隔符位置值
 * @return {*} 分隔符数量
 */
static int get_delims_number(char* src_strings, char* delims)
{
    if(delims == NULL)
        return 0;
    int delims_length = strlen(delims);
    int delim_number = 0, i = 0;
    delimnumber_expand(i);
    while((*src_strings) && (*src_strings) != '\0')
    {
        for(int j = 0; j < delims_length; j++)
        {
            if(*src_strings == delims[j])
            {
                delim_number++;
                delimnumber_expand(i + 1);
                break;
            }
        }
        i++;
        src_strings++;
    }
    return delim_number;
}

链表处理

struct _DelimNumber
{
    int value;
    struct _DelimNumber* next;
};
typedef struct _DelimNumber DelimNumber;
DelimNumber* delimnumber_head = NULL;
DelimNumber* delimnumber_end = NULL;
DelimNumber* delimnumber_next = NULL;

//链表扩张
static void delimnumber_expand(int value)
{
    DelimNumber *delimnumber = (DelimNumber*)malloc(sizeof(DelimNumber));
    delimnumber->value = value;
    delimnumber->next = NULL;

    if(delimnumber_head == NULL)
    {
        delimnumber_head = delimnumber;
    }
    else
    {
        delimnumber_end->next = delimnumber;
    }
    delimnumber_end = delimnumber;
}

//链表释放
static void delimnumber_free()
{
    DelimNumber *delimnumber = delimnumber_head;
    while(delimnumber_head->next)
    {
        DelimNumber * p = delimnumber_head;
        delimnumber_head = p->next;
        free(p);
    }
    delimnumber_head = NULL;
    delimnumber_end = NULL;
    delimnumber_next = NULL;
}

//链表迭代
static void delimnumber_next_value()
{
    if(delimnumber_next->next == NULL)
        return;
    delimnumber_next = delimnumber_next->next;
}

使用

编译

 mkdir build
 cd build
 cmake ..
 cmake --build .

测试

run StringSplitTest
test str:rdptsc://172.27.147.201:5905#d3VxaWFuZ193aW4xMA==####6f34c417-1359-4fad-ae29-b3e012412d2f##172.27.147.25#1111#user#123456

源码

gitee

其他

欢迎测试使用，如有问题留言或者提issue皆可。

Other

我的博客即将同步至腾讯云开发者社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=2wa3luj3xjmss