Thread: Dynamic string array inside a struct.

Just a quick question ; I'm trying to write a structure which can hold a bunch of strings and grow as more are added.

Usually when using an array of strings I'd implement it like this.

Code:

char **arr = malloc(25 * sizeof(char));
for(size_t i = 0 ; i < 250 ; i++)
         arr[i] = malloc(250);

Where 25 is the amount of elements and 250 is the size of the largest string I would want to store?

Without checking the returns value of malloc , this is just to show my thought process. Am I correct when I say that arr is now a pointer to a memory space which represents 25 other char pointers?

Thus arr[2] for example would be the third pointer in the array of pointers , which I could in turn malloc to make space for a string such as above?

Copying a value to this string would then work as

Code:

strcpy(arr[2],"Hello world");

Structure itself:

Code:

typedef struct string_table{
        char **data;
        size_t entries;
        size_t chunkSize;
        size_t stringSize;
}STRINGTABLE,stringTable;

Allocating memory for the structure and data.

Code:

STRINGTABLE *constructSt(size_t cs,size_t ss){
        STRINGTABLE *st = malloc(sizeof(STRINGTABLE));
        if(!st)
                return NULL;


        st->chunkSize = cs;
        st->stringSize = ss;
        st->entries = 0;


        st->data = malloc(cs);
        if(!st->data)
                return NULL;


        for(size_t i =0 ; i < cs ; i++){
                (st->data[i]) = malloc(ss);
                if(!(st->data[i]))
                        return NULL;
        }


        return st;
}

Originally Posted by RagingGrim

Am I correct when I say that arr is now a pointer to a memory space which represents 25 other char pointers?

Thus arr[2] for example would be the third pointer in the array of pointers , which I could in turn malloc to make space for a string such as above?

Yes, that is correct
EDIT: Except for the errors that laserlight caught that I didn't. Fix those.

Originally Posted by RagingGrim

Copying a value to this string would then work as

Code:

strcpy(arr[2],"Hello world");

Yes, though of course strcpy could run off the end of that array, and overflow; strncpy would be safer.

You're definitely on the right track. Some notes on your implementation though:

• Your struct members have slightly confusing names. A chunk to me sounds like one element of st->data, one chunk of memory the string occupies. chunkSize isn't really the chunk size then, it's max entries. stringSize isn't really string size, it's the size of one chunk (or element).
• If you intend data to represent a single string, you're causing extra work by using multiple chunks. Figuring out when you exceed the chunk size for an entry, and need to wrap to the next one is not much work, but it's is error prone, especially for buffer overrun and off-by-one type errors. Instead, look into using realloc to grow the string.
• Your malloc(cs) call is incorrect, you need to multiply by sizeof(*st->data)¹.
• If one of the later malloc's for data[i] fails, you need to free all the memory you allocated up to that point, otherwise you have a memory leak. Loop from i (or may i-1) back down to 0, calling free(st->data[i]). Then free(st->data). Then return NULL;
• If you are going to pre-allocate all the elements in data[i], you might as well just use a single large array, as you're not saving any memory.

¹ Note that I used the pointer itself here: sizeof(*st->data) instead of sizeof(char *). In general, that idiom is preferred, it means less work if you ever change the type of st->data. Imagine you want this code to start supporting unicode characters at some point. No need to change the malloc call, and no need to worry about forgetting to change it.