C语言-可变字符串数组的一种实现方式_c语言定义可变字符串-CSDN博客

本文链接：https://blog.csdn.net/weixin_50321513/article/details/128638461

文章介绍了一种在C语言中实现可变字符串数组的方法，通过动态内存分配和维护一个索引数组来定位字符串。虽然这种实现方式在删除操作时存在弊端，但适用于只需要添加而不删除字符串的场景。另一种可能的优化是使用链表结构。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

C语言-可变字符串数组的一种实现方式

头文件

#pragma once

#include "string.h"
#include "stdlib.h"

typedef struct stringSet
{
    char *data;
    int size;
    int data_length;
    int *index;
}stringSet;

void ss_init(stringSet* ss);
void ss_pushBack(stringSet* ss, const char* inputString);
char *ss_getString(stringSet* ss, int index);

.c文件

#include "stringSet.h"
#include "stdio.h"

#define SS_DEBUG 0

void ss_init(stringSet* ss)
{
    ss->data = (char*)malloc(sizeof(char));
    ss->index = (int*)malloc(sizeof(int));
    ss->size=0;
    ss->data_length = 0;
    return;
}

// add string back the 
void ss_push_back(stringSet* ss, const char* inputString)
{
    int length = strlen(inputString);
    ss->data = (char*)realloc(ss->data, sizeof(char) * (ss->data_length+1+length));
    strcpy(ss->data+ (ss->data_length==0?0:ss->data_length+1), inputString);
    ss->data[length] = '\0';
    ss->index = (int*)realloc(ss->index, sizeof(int) * (ss->size+1));
    ss->index[ss->size] = ss->data_length+(ss->size==0?0:1);
    ss->data_length += length+1;
    ss->size++;
    return ;
}

char *ss_get_string(stringSet* ss, int index)
{
    return ss->data+ss->index[index];
}

// #if(!S_DEBUG)
int main()
{
    stringSet* ss = (stringSet*)malloc(sizeof(stringSet));
    ss_init(ss);
    ss_push_back(ss, "Helloworld!\n");
    ss_push_back(ss, "Helloworld2!\n");
    ss_push_back(ss, "Helloworld3!\n");

    printf("data in stringSet:%s", ss->data);
    printf("data in stringSet:%s", ss_get_string(ss, 1));
    printf("data in stringSet:%s", ss_get_string(ss, 2));
    printf("%d\n", ss->size);
    return 0;
}
// #endif

测试结果：

data in stringSet:Helloworld!
data in stringSet:Helloworld2!
data in stringSet:Helloworld3!
3

思路：用字符数组存储，不使用二维数组，维护一个index数组，用以定位字符串位置，其中存储指向各个字符串初始位置的指针。由于字符串的末尾一定是\0故而可以采用此种方式进行存取。

弊端较为明显，一旦删除其中一个，之后的全部元素都需要向前，一个可以采取的思路是使用链表的方式进行存储。不过由于个人使用时只需要保存，不需要删除，故而可以对其进行使用。