C语言实现动态扩容的string

 更新时间:2023年04月02日 08:43:08   作者:小熊coder  
最近工作中使用C语言,但又苦于没有高效的字符串实现,字符串的拼接和裁剪都很麻烦,而且每个字符串都需要申请内存,内存的申请和释放也很容易出bug,怎么高效的实现一个不需要处理内存问题并且可以动态扩容进行拼接和裁剪的string呢?本文就来详细讲讲

众所周知,C++ 中的string使用比较方便。关于C++ 中的string源码实现,可以参考这篇文章:源码分析C++的string的实现

最近工作中使用C语言,但又苦于没有高效的字符串实现,字符串的拼接和裁剪都比较麻烦,而且每个字符串都需要申请内存,内存的申请和释放也很容易出bug,怎么高效的实现一个不需要处理内存问题并且可以动态扩容进行拼接和裁剪的string呢?

一个好的string应该有以下功能?

  • 创建字符串
  • 删除字符串
  • 尾部追加字符串
  • 头部插入字符串
  • 从尾部删除N个字符
  • 从头部删除N个字符
  • 裁剪字符串
  • 获取字符串长度
  • 获取完整字符串

下面,我们来看看各个功能的实现。

首先定义一个string的句柄,相当于C++中的实例。

struct c_string;
typedef struct c_string c_string_t;

在内部string的实现如下:

// string的初始内存大小
static const size_t c_string_min_size = 32;

struct c_string {
    char *str; // 字符串指针
    size_t alloced; // 已分配的内存大小
    size_t len; // 字符串的实际长度
};

创建字符串:

c_string_t *c_string_create(void) {
    c_string_t *cs;

    cs = calloc(1, sizeof(*cs));
    cs->str = malloc(c_string_min_size);
    *cs->str = '\0';
    // 初始分配内存大小是32,之后每次以2倍大小扩容
    cs->alloced = c_string_min_size; 
    cs->len = 0;

    return cs;
}

销毁字符串:

void c_string_destroy(c_string_t *cs) {
    if (cs == NULL) return;
    free(cs->str);
    free(cs);
}

内部如何扩容呢:

static void c_string_ensure_space(c_string_t *cs, size_t add_len) {
    if (cs == NULL || add_len == 0) return;

    if (cs->alloced >= cs->len + add_len + 1) return;

    while (cs->alloced < cs->len + add_len + 1) {
        cs->alloced <<= 1; // 每次以2倍大小扩容
        if (cs->alloced == 0) {
            // 左移到最后可能会变为0,由于alloced是无符号型,减一则会变成UINT_MAX
            cs->alloced--;
        }
    }
    cs->str = realloc(cs->str, cs->alloced);
}

在尾部追加字符串:

void c_string_append_str(c_string_t *cs, const char *str, size_t len) {
    if (cs == NULL || str == NULL || *str == '\0') return;

    if (len == 0) len = strlen(str);

    c_string_ensure_space(cs, len); // 确保内部有足够的空间存储字符串
    memmove(cs->str + cs->len, str, len);
    cs->len += len;
    cs->str[cs->len] = '\0';
}

在尾部追加字符:

void c_string_append_char(c_string_t *cs, char c) {
    if (cs == NULL) return;
    c_string_ensure_space(cs, 1);
    cs->str[cs->len] = c;
    cs->len++;
    cs->str[cs->len] = '\0';
}

在尾部追加整数:

void c_string_append_int(c_string_t *cs, int val) {
    char str[12];

    if (cs == NULL) return;

    snprintf(str, sizeof(str), "%d", val); // 整数转为字符串
    c_string_append_str(cs, str, 0);
}

在头部插入字符串:

void c_string_front_str(c_string_t *cs, const char *str, size_t len) {
    if (cs == NULL || str == NULL || *str == '\0') return;

    if (len == 0) len = strlen(str);

    c_string_ensure_space(cs, len);
    memmove(cs->str + len, cs->str, cs->len);
    memmove(cs->str, str, len);
    cs->len += len;
    cs->str[cs->len] = '\0';
}

在头部插入字符:

void c_string_front_char(c_string_t *cs, char c) {
    if (cs == NULL) return;
    c_string_ensure_space(cs, 1);
    memmove(cs->str + 1, cs->str, cs->len);
    cs->str[0] = c;
    cs->len++;
    cs->str[cs->len] = '\0';
}

在头部插入整数:

void c_string_front_int(c_string_t *cs, int val) {
    char str[12];

    if (cs == NULL) return;

    snprintf(str, sizeof(str), "%d", val);
    c_string_front_str(cs, str, 0);
}

清空字符串:

void c_string_clear(c_string_t *cs) {
    if (cs == NULL) return;
    c_string_truncate(cs, 0);
}

裁剪字符串:

void c_string_truncate(c_string_t *cs, size_t len) {
    if (cs == NULL || len >= cs->len) return;

    cs->len = len;
    cs->str[cs->len] = '\0';
}

删除头部的N个字符:

void c_string_drop_begin(c_string_t *cs, size_t len) {
    if (cs == NULL || len == 0) return;

    if (len >= cs->len) {
        c_string_clear(cs);
        return;
    }

    cs->len -= len;
    memmove(cs->str, cs->str + len, cs->len + 1);
}

删除尾部的N个字符:

void c_string_drop_end(c_string_t *cs, size_t len) {
    if (cs == NULL || len == 0) return;

    if (len >= cs->len) {
        c_string_clear(cs);
        return;
    }
    cs->len -= len;
    cs->str[cs->len] = '\0';
}

获取字符串的长度:

size_t c_string_len(const c_string_t *cs) {
    if (cs == NULL) return 0;
    return cs->len;
}

返回字符串指针,使用的是内部的内存:

const char *c_string_peek(const c_string_t *cs) {
    if (cs == NULL) return NULL;
    return cs->str;
}

重新分配一块内存存储字符串返回:

char *c_string_dump(const c_string_t *cs, size_t *len) {
    char *out;

    if (cs == NULL) return NULL;

    if (len != NULL) *len = cs->len;
    out = malloc(cs->len + 1);
    memcpy(out, cs->str, cs->len + 1);
    return out;
}

测试代码如下:

int main() {
    c_string_t *cs = c_string_create();
    c_string_append_str(cs, "123", 0);
    c_string_append_char(cs, '4');
    c_string_append_int(cs, 5);
    printf("%s \n", c_string_peek(cs));
    c_string_front_str(cs, "789", 0);
    printf("%s \n", c_string_peek(cs));
    c_string_drop_begin(cs, 2);
    printf("%s \n", c_string_peek(cs));
    c_string_drop_end(cs, 2);
    printf("%s \n", c_string_peek(cs));
    c_string_destroy(cs);
    return 0;
}

输出:

12345
78912345
912345
9123

完整代码如下:头文件:

#include <stddef.h>

struct c_string;
typedef struct c_string c_string_t;

c_string_t *c_string_create(void);

void c_string_destroy(c_string_t *cs);

void c_string_append_str(c_string_t *cs, const char *str, size_t len);

void c_string_append_char(c_string_t *cs, char c);

void c_string_append_int(c_string_t *cs, int val);

void c_string_front_str(c_string_t *cs, const char *str, size_t len);

void c_string_front_char(c_string_t *cs, char c);

void c_string_front_int(c_string_t *cs, int val);

void c_string_clear(c_string_t *cs);

void c_string_truncate(c_string_t *cs, size_t len);

void c_string_drop_begin(c_string_t *cs, size_t len);

void c_string_drop_end(c_string_t *cs, size_t len);

size_t c_string_len(const c_string_t *cs);

const char *c_string_peek(const c_string_t *cs);

char *c_string_dump(const c_string_t *cs, size_t *len);

源文件:

#include <ctype.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

static const size_t c_string_min_size = 32;

struct c_string {
    char *str;
    size_t alloced;
    size_t len;
};

c_string_t *c_string_create(void) {
    c_string_t *cs;

    cs = calloc(1, sizeof(*cs));
    cs->str = malloc(c_string_min_size);
    *cs->str = '\0';
    cs->alloced = c_string_min_size;
    cs->len = 0;

    return cs;
}

void c_string_destroy(c_string_t *cs) {
    if (cs == NULL) return;
    free(cs->str);
    free(cs);
}

static void c_string_ensure_space(c_string_t *cs, size_t add_len) {
    if (cs == NULL || add_len == 0) return;

    if (cs->alloced >= cs->len + add_len + 1) return;

    while (cs->alloced < cs->len + add_len + 1) {
        cs->alloced <<= 1;
        if (cs->alloced == 0) {
            cs->alloced--;
        }
    }
    cs->str = realloc(cs->str, cs->alloced);
}

void c_string_append_str(c_string_t *cs, const char *str, size_t len) {
    if (cs == NULL || str == NULL || *str == '\0') return;

    if (len == 0) len = strlen(str);

    c_string_ensure_space(cs, len);
    memmove(cs->str + cs->len, str, len);
    cs->len += len;
    cs->str[cs->len] = '\0';
}

void c_string_append_char(c_string_t *cs, char c) {
    if (cs == NULL) return;
    c_string_ensure_space(cs, 1);
    cs->str[cs->len] = c;
    cs->len++;
    cs->str[cs->len] = '\0';
}

void c_string_append_int(c_string_t *cs, int val) {
    char str[12];

    if (cs == NULL) return;

    snprintf(str, sizeof(str), "%d", val);
    c_string_append_str(cs, str, 0);
}

void c_string_front_str(c_string_t *cs, const char *str, size_t len) {
    if (cs == NULL || str == NULL || *str == '\0') return;

    if (len == 0) len = strlen(str);

    c_string_ensure_space(cs, len);
    memmove(cs->str + len, cs->str, cs->len);
    memmove(cs->str, str, len);
    cs->len += len;
    cs->str[cs->len] = '\0';
}

void c_string_front_char(c_string_t *cs, char c) {
    if (cs == NULL) return;
    c_string_ensure_space(cs, 1);
    memmove(cs->str + 1, cs->str, cs->len);
    cs->str[0] = c;
    cs->len++;
    cs->str[cs->len] = '\0';
}

void c_string_front_int(c_string_t *cs, int val) {
    char str[12];

    if (cs == NULL) return;

    snprintf(str, sizeof(str), "%d", val);
    c_string_front_str(cs, str, 0);
}

void c_string_clear(c_string_t *cs) {
    if (cs == NULL) return;
    c_string_truncate(cs, 0);
}

void c_string_truncate(c_string_t *cs, size_t len) {
    if (cs == NULL || len >= cs->len) return;

    cs->len = len;
    cs->str[cs->len] = '\0';
}

void c_string_drop_begin(c_string_t *cs, size_t len) {
    if (cs == NULL || len == 0) return;

    if (len >= cs->len) {
        c_string_clear(cs);
        return;
    }

    cs->len -= len;
    /* +1 to move the NULL. */
    memmove(cs->str, cs->str + len, cs->len + 1);
}

void c_string_drop_end(c_string_t *cs, size_t len) {
    if (cs == NULL || len == 0) return;

    if (len >= cs->len) {
        c_string_clear(cs);
        return;
    }
    cs->len -= len;
    cs->str[cs->len] = '\0';
}

size_t c_string_len(const c_string_t *cs) {
    if (cs == NULL) return 0;
    return cs->len;
}

const char *c_string_peek(const c_string_t *cs) {
    if (cs == NULL) return NULL;
    return cs->str;
}

char *c_string_dump(const c_string_t *cs, size_t *len) {
    char *out;

    if (cs == NULL) return NULL;

    if (len != NULL) *len = cs->len;
    out = malloc(cs->len + 1);
    memcpy(out, cs->str, cs->len + 1);
    return out;
}

到此这篇关于C语言实现动态扩容的string的文章就介绍到这了,更多相关C语言动态扩容string内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

相关文章

  • C++实现简单学生信息管理系统

    C++实现简单学生信息管理系统

    这篇文章主要为大家详细介绍了C++实现简单学生信息管理系统,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2022-03-03
  • 简述C++的复杂性

    简述C++的复杂性

    这篇文章主要介绍了简述C++的复杂性,帮助大家更好的理解和认识c++编程语言,感兴趣的朋友可以了解下
    2020-08-08
  • C语言获取文件大小的两种方式

    C语言获取文件大小的两种方式

    因为音视频开发的需要,经常会写一些文件输入输出的测试程序,常常用到获取文件大小的函数,本篇文章就记录一下常用的两种获取文件大小的方式,希望对大家有所帮助
    2023-11-11
  • C++实现支持泛型的LFU详解

    C++实现支持泛型的LFU详解

    这篇文章主要给大家介绍了关于C++实现LFU的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用Redis具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
    2021-09-09
  • C语言实现班级学生管理系统

    C语言实现班级学生管理系统

    这篇文章主要为大家详细介绍了C语言实现班级学生管理系统,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2021-11-11
  • C++实现LeetCode(11.装最多水的容器)

    C++实现LeetCode(11.装最多水的容器)

    这篇文章主要介绍了C++实现LeetCode(11.装最多水的容器),本篇文章通过简要的案例,讲解了该项技术的了解与使用,以下就是详细内容,需要的朋友可以参考下
    2021-07-07
  • c语言的cps实现求fibonacci数列示例

    c语言的cps实现求fibonacci数列示例

    这篇文章主要介绍了c语言的cps实现求fibonacci数列示例,需要的朋友可以参考下
    2014-03-03
  • C++实现广度优先搜索实例

    C++实现广度优先搜索实例

    这篇文章主要介绍了C++实现广度优先搜索,对于C++程序员来说非常有借鉴价值,需要的朋友可以参考下
    2014-08-08
  • C++类继承时的构造函数

    C++类继承时的构造函数

    这篇文章主要介绍了C++类继承时的构造函数,C++中,子类继承父类除去构造函数和析构函数以外的所有成员。因此,子类需要编写自己的构造函数和析构函数。更多相关详情需要的小伙伴可以参考下面文章介绍
    2022-03-03
  • C++的多态和虚函数你真的了解吗

    C++的多态和虚函数你真的了解吗

    这篇文章主要为大家详细介绍了C++的多态和虚函数,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下,希望能够给你带来帮助
    2022-02-02

最新评论