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

最新推荐文章于 2024-05-14 13:32:57 发布
最新推荐文章于 2024-05-14 13:32:57 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： C语言与C++编程 文章标签： 字符串 c++ 指针 malloc lighttpd

又好久没更新了，最近程序喵工作实在是太忙，业余时间也在学习新知识酝酿大招，便于后期更新好文，最近先水几篇吧，大家有想了解的知识点可以在文末读者讨论中留言哈！

众所周知，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;
}

编程与实战
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
订阅专栏
java 动态扩展方式
小范的技术空间
03-28 5104
java 除了在运行时连接类型之外，还可以在运行时动态决定连接哪一种类型。java的体系结构允许动态扩展java程序，过程包括运行时决定所使用的类型，装载它们，使用它们。一、动态扩展的方法通过传递类型的名称，使用java.lang.class的forName()方法。通过用户自定义的类装载器的loadClass()方法，用户自定义的类装载器可以从java.c
【转】C语言实现string类型
bafei4705的博客
06-23 1334
转自：http://www.amobbs.com/thread-5585526-1-1.html8楼 封装一个String类型 typedef struct { char* charArr; int16_t len; }StringStruct; #define String(n,m) \ StringStruct n={m,sizeof(m)} ...
c语言string类函数及自实现
菜鸡成长站
10-30 649
字符串日常tip/problem 字符串函数 10.30遇到了strchr strchr函数的使用： char * strchr(consit char * s,int c) 如果s字符串中包含c字符，该函数返回指向s字符串首位置的指针（末尾的空字符也是字符串的一部分，所以在查找范围内);如果在字符串s中未找到c字符，该函数返回空指针。 ...
C动态数组_添加元素后动态扩容
最新发布
happy3581的博客
05-14 225
C动态数组，自动扩容。
尝试实现一个简单的C语言string类型
ding7530的博客
01-25 167
　　用过`C++/Java/python/matlab/JS`等语言后，发现都能很轻松的使用string类型，而C只能这样： char str[] = "hello world"; or const char* str = "hello world"; 　　如果只是一个string的类型的话，可以简单的自定义一个： typedef const char* stri...
C++中自定义string类的实现
weixin_44548016的博客
07-06 162
C++中自定义string类的实现 mystring.h头文件 #ifndef MYSTRING_H #define MYSTRING_H #include <ostream> #include <cstring> using namespace std; class MyString { public: MyString(); //无参构造函数 MyString(const char *str); //有参构造函数 MyString(const MySt
基于C语言的数据结构-哈希表hashTable
06-25
5. 装载因子调整：装载因子是指哈希表中元素数量与表大小的比值，当装载因子过大时，冲突率上升，需要动态扩容。 三、优化与性能 1. 动态扩容：当装载因子超过某个阈值时，可以扩大哈希表的大小，并重新哈希所有...
A simple string hashmap in C.zip
12-27
6. **负载因子**：负载因子是已存元素数量与哈希表容量的比值，当负载因子过高时，性能可能会下降，此时可能需要扩容哈希表。 7. **冲突解决策略**：常见的冲突解决策略有链地址法（每个索引位置是一个链表）、开放...
C语言数据结构各种程序源代码
06-13
在C语言中，顺序表的源码可能包含添加、删除、查找等操作，但需要注意数组的动态扩容问题。 8. **稀疏矩阵**：稀疏矩阵是指大量元素为零的矩阵，为了节省存储空间，通常采用压缩存储的方式，如三元组表示法或十字链...
redis字符串类型_Java学院整理
01-19
第一：如果你每次都执行Append函数，那是不是redis的char[]每次都需要再次扩容，这样是不是每次都是耗时操作呢？ 第二：如果你每次执行String中的StrLen，那redis底层是不是每次都要遍历char数组来得到结果呢？ 一、...
Redis数据库知识点.docx
06-26
3. 在线扩容困难：当集群容量达到上限时，扩展较为复杂，需要预先规划足够的空间。 Redis 的数据类型和底层实现： 1. String：底层使用简单动态字符串（SDS），可以存储最多512MB的数据。 2. Hash：采用压缩列表或...
layui树形菜单动态遍历的例子
10-16
今天小编就为大家分享一篇layui树形菜单动态遍历的例子，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Layui实现动态加载Tree
Dawn.x的博客
07-01 6422
目录前言基本使用尾言 前言 有空研究了一下Layui，感觉相对于EasyUI来说，美观了不少，接下来给大家介绍一下它的基本使用 基本使用 Layui官网 去官网下载好Layui,里面有示例和css、js等文件 具体使用步骤： 要使用Layui,必须引入css文件和js文件： <link rel="stylesheet" href="css/layui.css" /> Layui官方文档是说有两种加载方式的，也就是：非模块化方式和模块化方式 两者区别就是： 非模块化方式所有模块一次性加载
layUI之动态树
m12120426的博客
07-17 445
1.layUI官网，如何显示菜单数据------>HTML2.从HTML代码推断，需要什么样的数据格式------>数据必须存在父子关系3.读取数据表，拿到菜单相关的数据---->数据是平级，不存在父子关系4.解释了工具类的底层原理5.调用工具类，将平级的菜单数据，转换了具备父子关系的菜单数据6.后台代码补全action、mvc.xml配置7.前台调用action，并且利用$.ajax获取数据，然后通过$.each构建第一步中的HTML代码httpshttpshttpshttps。...
Layui之动态树
weixin_64313980的博客
07-21 497
将t_oa_permission表中的列名编写在实体类当中，在数据库中使用指令desc*from表名查看表结构以此判断列名的数据类型。下一期我们将对本期内容进行巩固，切换一张数据表来进行同样的展示若本期内容有误或者不足还望指出！permissionDaoTest测试。注意数据类型需要保持一致，否则无效。从layui中得到的动态树模型代码。我们需要将如下数据展示在动态树当中。三，将表中的数据构建父子关系。一，分析左侧树形菜单。......
10届国赛java B组蓝桥杯： 最长子序列
weixin_46640345的博客
01-10 298
最长子序列 【问题描述】 我们称一个字符串S包含字符串T是指T是S的一个子序列，即可以从字符串S中抽出若干个字符，它们按原来的顺序组合成一个新的字符串与T完全一样。 给定两个字符串S和T，请问最少修改S中的多少个字符，能使S包含T ? 【输入格式】 输入两行，每行一个字符串。第一行的字符串为s，第二行的字符串为T。两个字符串均非空而且只包含大写英文字母。 【输出格式】 输出一个整数，表示答案。 【样例输入】 ABCDEABCD AABZ 【样例输出】 3 思路： 思路很简单，从头到尾遍历串S，遇到与 t[
layui之动态树（二级）
m0_62528678的博客
07-17 467
二级管理菜单
layui的tree如何实现动态加载_layui tree动态加载 利用CAReplicatorLayer实现的加载动画 - 电脑常识 - 服务器之家...
weixin_39604092的博客
12-20 191
layui tree动态加载 利用CAReplicatorLayer实现的加载动画发布时间：2017-04-12来源：服务器之家在上一篇中，笔者简要介绍了CAReplicatorLayer，在本篇中，将介绍具体的实用价值。实用CAReplicatorLayer作为核心技术实现加载动画。首先，创建一个UIView的子类@interface JHHJView : UIView然后该子类暴露出一些类方法...
c语言实现malloc的内存不够了扩容
05-19
在C语言中，可以使用realloc函数来扩展动态内存分配的空间。realloc函数的原型为： ``` void *realloc(void *ptr, size_t size); ``` 其中，ptr是之前使用malloc函数分配的内存空间的指针，size是需要扩展的内存大小。realloc函数会重新分配一块内存空间，并将ptr指向的内存内容复制到新的内存空间中。如果扩展内存成功，realloc函数会返回一个指向新内存空间的指针，否则返回NULL。 通常情况下，我们可以先使用malloc函数分配一块初始内存空间，然后在需要扩展内存时，使用realloc函数重新分配一块更大的内存空间，并将之前的数据复制到新的内存空间中。具体示例代码如下： ``` #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { // 初始内存大小 int init_size = 10; // 分配初始内存空间 char *str = (char *) malloc(init_size * sizeof(char)); if (str == NULL) { printf("malloc failed.\n"); return 1; } // 输入字符串 printf("Enter a string: "); if (fgets(str, init_size, stdin) != NULL) { // 如果输入的字符串超过了初始内存空间大小，则使用realloc函数扩展内存空间 if (str[strlen(str) - 1] != '\n') { int new_size = init_size * 2; char *new_str = (char *) realloc(str, new_size * sizeof(char)); if (new_str == NULL) { printf("realloc failed.\n"); free(str); return 1; } else { str = new_str; fgets(str + init_size, init_size, stdin); init_size = new_size; } } printf("Input string is: %s\n", str); } // 释放内存空间 free(str); return 0; } ``` 在上述示例代码中，我们使用fgets函数从标准输入中读取用户输入的字符串，如果输入的字符串长度超过了初始内存空间大小，则使用realloc函数扩展内存空间，并将新的字符串输入到扩展后的内存空间中。最后，释放内存空间并返回0表示程序正常结束。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值