当前位置：首页 > 公众号精选 > 程序喵大人

C语言如何实现动态扩容的string

时间：2020-10-24 22:18:25
关键字： C语言    嵌入式   
手机看文章

扫描二维码
随时随地手机看文章

[导读]最近工作中使用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 

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 
#include 
#include 
#include 
#include 

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;
}

往期推荐





免责声明：本文内容由21ic获得授权后发布，版权归原作者所有，本平台仅提供信息存储服务。文章仅代表作者个人观点，不代表本平台立场，如有问题，请联系我们，谢谢！

本站声明： 本文章由作者或相关机构授权发布，目的在于传递更多信息，并不代表本站赞同其观点，本站亦不保证或承诺内容真实性等。需要转载请联系该专栏作者，如若文章内容侵犯您的权益，请及时联系本站删除。
换一批
延伸阅读
[通信先锋]

阿维塔、赛力斯已入股！华为引望可能成“中国博世”

9月2日消息，不造车的华为或将催生出更大的独角兽公司，随着阿维塔和赛力斯的入局，华为引望愈发显得引人瞩目。

关键字： 阿维塔 塞力斯 华为
[美通社全球TMT]

Trianz与AWS达成战略合作协议，彻底改变云采用和管理方式

加利福尼亚州圣克拉拉县2024年8月30日 /美通社/ -- 数字化转型技术解决方案公司Trianz今天宣布，该公司与Amazon Web Services （AWS）签订了...

关键字： AWS AN BSP 数字化
[美通社全球TMT]

人工智能驱动工具SODA V将颠覆汽车市场，使汽车开发时间和成本降低90%

伦敦2024年8月29日 /美通社/ -- 英国汽车技术公司SODA.Auto推出其旗舰产品SODA V，这是全球首款涵盖汽车工程师从创意到认证的所有需求的工具，可用于创建软件定义汽车。 SODA V工具的开发耗时1.5...

关键字： 汽车 人工智能 智能驱动 BSP
[美通社全球TMT]

从容应对未知风险----解密亚马逊云科技的韧性之道

北京2024年8月28日 /美通社/ -- 越来越多用户希望企业业务能7×24不间断运行，同时企业却面临越来越多业务中断的风险，如企业系统复杂性的增加，频繁的功能更新和发布等。如何确保业务连续性，提升韧性，成...

关键字： 亚马逊 解密 控制平面 BSP
[通信先锋]

中国游戏市场开始复苏！腾讯、网易等巨头缩减在日本投资

8月30日消息，据媒体报道，腾讯和网易近期正在缩减他们对日本游戏市场的投资。

关键字： 腾讯 编码器 CPU
[通信先锋]

独立自主！华为董事：致力打造不依赖西方的技术

8月28日消息，今天上午，2024中国国际大数据产业博览会开幕式在贵阳举行，华为董事、质量流程IT总裁陶景文发表了演讲。

关键字： 华为 12nm EDA 半导体
[通信先锋]

华为张平安：数字世界话语权最终由生态繁荣决定！

8月28日消息，在2024中国国际大数据产业博览会上，华为常务董事、华为云CEO张平安发表演讲称，数字世界的话语权最终是由生态的繁荣决定的。

关键字： 华为 12nm 手机 卫星通信
[美通社全球TMT]

中国通信服务公布2024年中期业绩

要点： 有效应对环境变化，经营业绩稳中有升 落实提质增效举措，毛利润率延续升势 战略布局成效显著，战新业务引领增长 以科技创新为引领，提升企业核心竞争力 坚持高质量发展策略，塑强核心竞争优势...

关键字： 通信 BSP 电信运营商 数字经济
[美通社全球TMT]

NVI技术创新联盟成立！自主生态将带动产业链高速发展

北京2024年8月27日 /美通社/ -- 8月21日，由中央广播电视总台与中国电影电视技术学会联合牵头组建的NVI技术创新联盟在BIRTV2024超高清全产业链发展研讨会上宣布正式成立。 活动现场 NVI技术创新联...

关键字： VI 传输协议 音频 BSP
[美通社全球TMT]

软通动力与长三角投资达成战略合作 共谋数字生态新发展

北京2024年8月27日 /美通社/ -- 在8月23日举办的2024年长三角生态绿色一体化发展示范区联合招商会上，软通动力信息技术（集团）股份有限公司（以下简称"软通动力"）与长三角投资（上海）有限...

关键字： BSP 信息技术
关闭
关闭