C语言实现类似 Java 的 StringBuffer 字符串缓冲区 StrBuf

系统管理员 2021-09-21 23:48 234阅读 0赞

本文链接: [https://xiets.blog.csdn.net/article/details/116458996][https_xiets.blog.csdn.net_article_details_116458996]

C语言 使用 结构体 和 链表 实现类似 Java 的 StringBuffer 字符串缓冲区 `StrBuf`。缓冲区内部根据添加的字符数量自动扩展。支持 创建缓冲区、获取缓冲区大小、添加字符串/字符、输出缓冲的字符串。

# 1. StrBuf 源码实现 #

头文件: `str_buf.h`

// Copyright © 2021 xietansheng. All rights reserved.
    
    #ifndef str_buf_h
    #define str_buf_h
    
    /* 每一个缓冲区块存储子字符串的字符数组大小 */
    #define LINKED_PART_SIZE 256
    
    /* 字符串缓冲区结构体（链表结构） */
    struct __StrBuf { 
        /* 字符串分段存储区块数组 */
        char __charsPart[LINKED_PART_SIZE];
        /* 指向下一个结构体的指针 */
        struct __StrBuf* __pNext;
    };
    
    /* 字符串缓冲区结构体别名（外部使用）*/
    typedef struct __StrBuf StrBuf;
    
    
    /* 创建一个 StrBuf 结构体, 返回其指针, 使用完后必须成对调用 StrBuf_Free() 释放 StrBuf 指针 */
    StrBuf* StrBuf_New(void);
    
    
    /* 计算 StrBuf 已缓冲的字符串长度 */
    int StrBuf_Length(StrBuf* pStr);
    
    
    /* 向 StrBuf 缓冲区添加字符串。charStrLength 表示从 pCharStr 字符串中复制多少 个字符添加到缓冲区, 最长截止到 '\0' 前一个, 传 -1 表示添加到 '\0' 前一个为止。*/
    void StrBuf_Append(StrBuf* pStr, char* pCharStr, int charStrLength);
    /* 向 StrBuf 中添加字符 */
    void StrBuf_AppendChar(StrBuf* pStr, char c);
    
    
    /* StrBuf 中缓冲的字符串保存到 pOutBuf 中, pOutBuf 指向的数组空间大小至少为 StrBuf_Length + 1 */
    void StrBuf_ToCharArray(StrBuf* pStr, char* pOutBuf);
    
    
    /* StrBuf 中缓冲的字符串输出到控制台（方便查看）*/
    void StrBuf_PrintString(StrBuf* pStr);
    
    
    /* 释放 StrBuf 指针指向的内存空间 */
    void StrBuf_Free(StrBuf* pStr);
    
    
    #undef LINKED_PART_SIZE
    
    #endif

源文件: `str_buf.c`

// Copyright © 2021 xietansheng. All rights reserved.
    
    #include "str_buf.h"
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    
    /* * 创建一个 StrBuf 结构体, 返回其指针, 使用完后必须成对调用 StrBuf_Free() 释放 StrBuf 指针 */
    StrBuf* StrBuf_New(void) { 
        StrBuf* pStr = (StrBuf*) malloc(sizeof(StrBuf));
        
        int partSize = sizeof(pStr->__charsPart);
        int i = 0;
        
        for (i = 0; i < partSize; i++) { 
            *(pStr->__charsPart + i) = '\0';
        }
        
        pStr->__pNext = NULL;
        
        return pStr;
    }
    
    
    /* * 计算 StrBuf 已缓冲的字符串长度 */
    int StrBuf_Length(StrBuf* pStr) { 
        int length = 0;
        
        while (pStr != NULL) { 
            length += strlen(pStr->__charsPart);
            pStr = pStr->__pNext;
        }
        
        return length;
    }
    
    
    /* * 向 StrBuf 缓冲区添加字符串。charStrLength 表示从 pCharStr 字符串中复制多少 * 个字符添加到缓冲区, 最长截止到 '\0' 前一个, 传 -1 表示添加到 '\0' 前一个为止。 */
    void StrBuf_Append(StrBuf* pStr, char* pCharStr, int charStrLength) { 
        int partMaxLen = sizeof(pStr->__charsPart) - 1;     // 每个缓冲区块存储字符的最大数量
        int lastPartLen = 0;                                // 最后一个缓冲区块存储已存储的字符数量
        int appendedCount = 0;                              // 已添加的字符串数量
        StrBuf* pLast = pStr;                               // 指向最后一个缓冲区块
        
        while (pLast->__pNext != NULL) {                     // 找出最后一个缓冲区块
            pLast = pLast->__pNext;
        }
        lastPartLen = (int) strlen(pLast->__charsPart);     // 计算最后一个缓冲区块已存储的字符数量
        
        while (*pCharStr != '\0' && (charStrLength < 0 || appendedCount < charStrLength)) { 
            if (lastPartLen < partMaxLen) { 
                // 最后一个缓冲区块还有剩余空间可以存储字符, 继续存储
                *(pLast->__charsPart + lastPartLen) = *pCharStr;
                appendedCount++;
                lastPartLen++;
                pCharStr++;
            } else { 
                // 最后一个缓冲区块已存满, 写入字符串结束标记
                *(pLast->__charsPart + lastPartLen) = '\0';
                // 新建一个缓冲区块, 拼接到链表尾部
                pLast->__pNext = StrBuf_New();
                pLast = pLast->__pNext;
                lastPartLen = 0;
            }
        }
        
        *(pLast->__charsPart + lastPartLen) = '\0';         // 写完最后一个缓冲区块, 添加字符串结束标记
    }
    
    
    /* * 向 StrBuf 中添加字符 */
    void StrBuf_AppendChar(StrBuf* pStr, char c) { 
        char buf[2];
        buf[0] = c;
        buf[1] = '\0';
        StrBuf_Append(pStr, buf, -1);
    }
    
    
    /* * StrBuf 中缓冲的字符串保存到 pOutBuf 中, pOutBuf 指向的数组空间大小至少为 StrBuf_Length + 1 */
    void StrBuf_ToCharArray(StrBuf* pStr, char* pOutBuf) { 
        *pOutBuf = '\0';        // 先清空原字符串
        while (pStr != NULL) { 
            strcat(pOutBuf, pStr->__charsPart);
            pStr = pStr->__pNext;
        }
    }
    
    
    /* * StrBuf 中缓冲的字符串输出到控制台（方便查看） */
    void StrBuf_PrintString(StrBuf* pStr) { 
        int strLen = StrBuf_Length(pStr);
        char* pOutBuf = (char*) malloc(sizeof(char) * (strLen + 1));
        StrBuf_ToCharArray(pStr, pOutBuf);
        printf("--- StrBuf_PrintString ---\n");
        printf("%s\n", pOutBuf);
        printf("--- Length: %d ---\n", strLen);
        free(pOutBuf);
    }
    
    
    /* * 释放 StrBuf 指针指向的内存空间 */
    void StrBuf_Free(StrBuf* pStr) { 
        StrBuf* pNext = NULL;
        while (pStr != NULL) { 
            pNext = pStr->__pNext;
            free(pStr);
            pStr = pNext;
        }
    }

# 2. StrBuf 使用示例 #

源文件: `main.c`

// Copyright © 2021 xietansheng. All rights reserved.
    
    #include <stdio.h>
    #include <stdlib.h>
    
    #include "str_buf.h"
    
    int main(int argc, char* argv[]) { 
        char* pOutBuf = NULL;
        
        // 创建 StrBuf 结构体指针
        StrBuf* pStr = StrBuf_New();
        
        // 添加字符串
        StrBuf_Append(pStr, "abc", -1);
        StrBuf_Append(pStr, "123", -1);
        StrBuf_Append(pStr, "HelloWorld", -1);
        // 添加单个字符
        StrBuf_AppendChar(pStr, 'X');
        StrBuf_AppendChar(pStr, 'Y');
        StrBuf_AppendChar(pStr, 'Z');
        
        // 输出字符串到控制台
        StrBuf_PrintString(pStr);
        
        // 动态创建字符数组, 大小需足以容纳 StrBuf 中缓冲的字符数量（包括字符串结束符）
        pOutBuf = (char*) malloc( sizeof(char) * (StrBuf_Length(pStr) + 1) );
        // 把 StrBuf 中缓冲的字符串输出到 pOutBuf
        StrBuf_ToCharArray(pStr, pOutBuf);
        // 输出字符串到控制台
        printf("\nstr = %s\n", pOutBuf);
        // 释放 pOutBuf 指向的内存空间
        free(pOutBuf);
        
        // 释放 StrBuf 指针指向的内存空间
        StrBuf_Free(pStr);
        
        return 0;
    }

把 `str_buf.h`、`str_buf.c`、`main.c` 放到同一目录，使用 GCC 编译运行（MAC/Linux）:

$ gcc str_buf.c main.c -o main
    $ ./main 
    --- StrBuf_PrintString ---
    abc123HelloWorldXYZ
    --- Length: 19 ---
    
    str = abc123HelloWorldXYZ

# 3. StrBuf 结合 popen() 函数的使用 #

`popen()` 函数通过创建一个管道执行一条命令并返回一个标准 I/O 流，可从其中读取/写入数据。下面通过 popen() 函数执行一条命令，并把结果保存到 StrBuf 中:

// Copyright © 2021 xietansheng. All rights reserved.
    
    #include <stdio.h>
    #include <stdlib.h>
    
    #include "str_buf.h"
    
    #define POPEN_BUF_SIZE 1024
    
    
    void Shell_Popen(char* cmd, StrBuf* pStrBuf) { 
        char buf[POPEN_BUF_SIZE] = { '\0'};
    
        FILE* pipe = popen(cmd, "r");       // 不考虑错误输出
        
        if (!pipe) { 
            sprintf(buf, "ERROR: popen return NULL, CMD: %s\n", cmd);
            return;
        }
        
        // fgets 从管道中最多读取 (POPEN_BUF_SIZE - 1) 个有效字符, 
        // 然后自动接上一个 '\0' 结束符, 没有更多可读取的字符时返回 NULL 
        while (fgets(buf, POPEN_BUF_SIZE, pipe)) { 
            StrBuf_Append(pStrBuf, buf, -1);
        }
        
        pclose(pipe);
    }
    
    
    int main(int argc, char* argv[]) { 
        char* pOutBuf = NULL;
        StrBuf* pStrBuf = StrBuf_New();
    
        // 执行一条命令, 结果保存到 pStrBuf 缓冲区中（不考虑错误输出）
        Shell_Popen("gcc --version", pStrBuf);
    
        // 获取 pStrBuf 缓冲区中的缓冲的字符串
        pOutBuf = (char*) malloc( sizeof(char) * (StrBuf_Length(pStrBuf) + 1) );
        StrBuf_ToCharArray(pStrBuf, pOutBuf);
        printf("CMD RESULT:\n%s\n", pOutBuf);
        free(pOutBuf);
        
        StrBuf_Free(pStrBuf);
        return 0;
    }

运行结果:

CMD RESULT:
    Apple clang version 12.0.0 (clang-1200.0.31.1)
    Target: x86_64-apple-darwin19.6.0
    Thread model: posix
    InstalledDir: /Library/Developer/CommandLineTools/usr/bin

[https_xiets.blog.csdn.net_article_details_116458996]: https://xiets.blog.csdn.net/article/details/116458996