最新国产好看的视频,伊人天堂AV在线,国产Aaaaaa视频,蜜臀视频在线观看一区,人妻av色图,密臀久久久精品影片,青青视频免费观看毛片,久草在线观看视,国产三级精品色情在线

C語言實現動態(tài)擴容的string

 更新時間：2023年04月02日 08:43:08   作者：小熊coder  
最近工作中使用C語言，但又苦于沒有高效的字符串實現，字符串的拼接和裁剪都很麻煩，而且每個字符串都需要申請內存，內存的申請和釋放也很容易出bug，怎么高效的實現一個不需要處理內存問題并且可以動態(tài)擴容進行拼接和裁剪的string呢？本文就來詳細講講

眾所周知，C++ 中的string使用比較方便。關于C++ 中的string源碼實現，可以參考這篇文章：源碼分析C++的string的實現

最近工作中使用C語言，但又苦于沒有高效的字符串實現，字符串的拼接和裁剪都比較麻煩，而且每個字符串都需要申請內存，內存的申請和釋放也很容易出bug，怎么高效的實現一個不需要處理內存問題并且可以動態(tài)擴容進行拼接和裁剪的string呢？

一個好的string應該有以下功能？

  • 創(chuàng)建字符串
  • 刪除字符串
  • 尾部追加字符串
  • 頭部插入字符串
  • 從尾部刪除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; // 字符串的實際長度
};

創(chuàng)建字符串：

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) {
            // 左移到最后可能會變?yōu)?，由于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語言實現動態(tài)擴容的string的文章就介紹到這了,更多相關C語言動態(tài)擴容string內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

相關文章

  • Visual Studio 2022無法打開源文件的解決方式

    Visual Studio 2022無法打開源文件的解決方式

    這篇文章主要介紹了Visual Studio 2022無法打開源文件的解決方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教
    2023-01-01
  • C語言循環(huán)鏈表的原理與使用操作

    C語言循環(huán)鏈表的原理與使用操作

    無論是靜態(tài)鏈表還是動態(tài)鏈表，有時在解決具體問題時，需要我們對其結構進行稍微地調整。比如，可以把鏈表的兩頭連接，使其成為了一個環(huán)狀鏈表，通常稱為循環(huán)鏈表
    2022-05-05
  • C++中sort()函數和priority_queue容器中比較函數的區(qū)別詳析

    C++中sort()函數和priority_queue容器中比較函數的區(qū)別詳析

    C++中sort()和priority_queue都能自定義比較函數,其中sort()自定義的比較函數比較好理解,priority_queue中自定義的比較函數的效果和sort()是相反的,這篇文章主要給大家介紹了關于C++中sort()函數和priority_queue容器中比較函數的區(qū)別的相關資料,需要的朋友可以參考下
    2023-03-03
  • C語言實現選擇排序、直接插入排序、冒泡排序的示例

    C語言實現選擇排序、直接插入排序、冒泡排序的示例

    這篇文章主要介紹了C++實現選擇排序、直接插入排序、冒泡排序的代碼示例,相當簡潔直觀,也是算法和數據結構學習中的基礎,需要的朋友可以參考下
    2016-02-02
  • 基于Opencv實現雙目攝像頭拍照程序

    基于Opencv實現雙目攝像頭拍照程序

    這篇文章主要為大家詳細介紹了基于Opencv實現雙目攝像頭拍照程序，具有一定的參考價值，感興趣的小伙伴們可以參考一下
    2019-04-04
  • C++之WSAAsyncSelect模型實例

    C++之WSAAsyncSelect模型實例

    這篇文章主要介紹了C++的WSAAsyncSelect模型,實例講述了socket與Windows消息機制的用法,需要的朋友可以參考下
    2014-10-10
  • c++重載的詳細總結

    c++重載的詳細總結

    作為成員函數重載符，對于雙目操作符重載函數只需一個形參，對于單目操作符重載函數不需要形參
    2013-09-09
  • C++基礎算法基于哈希表的索引堆變形

    C++基礎算法基于哈希表的索引堆變形

    這篇文章主要為大家介紹了C++基礎算法，基于哈希表的索引堆變形示例詳解，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步
    2021-10-10
  • 詳解C語言實現猜數字游戲

    詳解C語言實現猜數字游戲

    這篇文章主要為大家介紹了C語言實現猜數字游戲，具有一定的參考價值，感興趣的小伙伴們可以參考一下，希望能夠給你帶來幫助<BR>
    2022-01-01
  • 一文詳解C++子類函數為什么不能重載父類函數

    一文詳解C++子類函數為什么不能重載父類函數

    這篇文章主要介紹了一文詳解C++子類函數為什么不能重載父類函數，文章圍繞主題展開詳細的內容戒殺，具有一定的參考價值，需要的朋友可以參考一下
    2022-09-09

最新評論

岳阳市| 沧源| 左权县| 竹溪县| 南昌县| 涟水县| 长宁县| 保靖县| 安化县| 修武县| 朝阳市| 班玛县| 巫溪县| 合肥市| 九台市| 阿坝| 青神县| 龙南县| 青冈县| 外汇| 东安县| 山阴县| 垫江县| 崇仁县| 左权县| 郧西县| 乌兰县| 分宜县| 贵德县| 乳山市| 丹凤县| 荆州市| 施秉县| 科技| 南通市| 奉节县| 玛纳斯县| 肃宁县| 通城县| 晋宁县| 新晃|