Dynamically growing array of strings in C

Question

I want to create an array of variable size that stores strings of maximum length 40. I have performed research and found the following code,which creates a dynamic array of integers.

typedef struct {
  int *array;
  size_t used;
  size_t size;
} Array;

void initArray(Array *a, size_t initialSize) {
  a->array = malloc(initialSize * sizeof(int));
  a->used = 0;
  a->size = initialSize;
}

void insertArray(Array *a, int element) {
  // a->used is the number of used entries, because a->array[a->used++] updates a->used only *after* the array has been accessed.
  // Therefore a->used can go up to a->size 
  if (a->used == a->size) {
    a->size *= 2;
    a->array = realloc(a->array, a->size * sizeof(int));
  }
  a->array[a->used++] = element;
}

void freeArray(Array *a) {
  free(a->array);
  a->array = NULL;
  a->used = a->size = 0;
}

I am currently trying to modify the code, to make it work for my problem. I have so far come up with this

typedef struct {
  
  size_t used;
  size_t size;
  char *array[][40];
} Array;

void initArray(Array *a, size_t initialSize) {
  a->array = malloc(initialSize * sizeof(char));
  a->used = 0;
  a->size = initialSize;
}

void insertArray(Array *a, char element) {
  // a->used is the number of used entries, because a->array[a->used++] updates a->used only *after* the array has been accessed.
  // Therefore a->used can go up to a->size 
  if (a->used == a->size) {
    a->size *= 2;
    a->array = realloc(a->array, a->size * sizeof(char));
  }
  strcpy(a->array[a->used++], element);
}

Finally

Array a;
char srcname[40];
initArray(&a, 100); 
insertArray(&a, srcname);

This produces a segmentation fault. Although I have researched, I have not managed to make a working dynamic array of strings. Any guidance would be appreciated

char *array[][40] doesn't declare what you think it does. This code shouldn't compile, much less produce a segmentation fault at runtime. — WhozCraig
– WhozCraig, Commented Nov 18, 2021 at 21:31
You probably should have an array of pointers to strings. The code will be probably a bit simpler and as a benefit you'll be able to store strings of any length. — Jabberwocky
– Jabberwocky, Commented Nov 18, 2021 at 21:33

0___________ · Accepted Answer · 2021-11-18 23:28:07Z

If you want to store the strings with max length of 40 characters including the terminating null character, you can use flexible array members. You do not special function to initialize the array, the string adding one will do initialization as well (you only need to pass NULL as a parameter showing that the array was not initialized yet). The function automatically changes the size of the string array in the steps defined in STEP macrodefinition.

typedef struct {
  size_t used;
  size_t size;
  char array[][40];
} Array;

#define STEP    64

Array *addString(Array *arr, const char *str)
{
    size_t newsize;
    if(!arr || arr -> size == arr -> used)
    {
        newsize = arr ? arr -> size + STEP : STEP;
        arr = realloc(arr, sizeof(*arr) + newsize * sizeof(arr -> array[0]));
        arr -> size = newsize;
        arr -> used = newsize == STEP ? 0 : arr -> used;
    }
    if(arr)
    {
        strncpy(arr -> array[arr -> used], str, sizeof(arr -> array[0]));
        arr -> array[arr -> used][sizeof(arr -> array[0]) - 1] = 0;
        arr -> used++;
    } 
    return arr;
}

int main(void)
{
    Array *arr = NULL, *tmp;

    // function wrks same as realloc so you need to assign the temp variable to
    // avoid memory leak in case of error. I will skip it for the simplicity of the example

    for(size_t i = 0; i < 256; i++)
    {
        char str[40];
        sprintf(str,"String no: %zu", i);
        arr = addString(arr, str);
        printf("Array: size: %3zu used: %3zu\n", arr -> size, arr -> used);
    }

    for(size_t i = 0; i < 256; i++)
    {
        printf("Array sting no %zu: `%s`\n", i, arr -> array[i]);
    }
}

https://godbolt.org/z/8E7EbeaW7

Vlad from Moscow · Accepted Answer · 2021-11-18 21:45:09Z

The declaration of the data member array in the structure

typedef struct {
  
  size_t used;
  size_t size;
  char *array[][40];
} Array;

is incorrect.

If you want to declare a pointer then you need to write

typedef struct {
  
  size_t used;
  size_t size;
  char ( *array )[40];
} Array;

The function initArray is also incorrect.

void initArray(Array *a, size_t initialSize) {
  a->array = malloc(initialSize * sizeof(char));
  a->used = 0;
  a->size = initialSize;
}

because there is allocated an incorrect array.

The function can look the following way

int initArray( Array *a, size_t initialSize) 
{
    a->used = 0;

    a->array = malloc( initialSize * sizeof( char[40] ) );
    int success = a->array != NULL;
    
    if ( success )
    {  
        a->size = initialSize;
    }
    else
    {
        a->size = 0;
    }

    return success;
}

Correspondingly the function insertArray (that has an incorrect type of the second parameter because you are going to pass a string not a single character are not you?) should be declared and defined like

int insertArray( Array *a, const char *element ) 
{
    int success = 1;

    if ( a->used == a->size ) 
    {
        char ( *tmp )[40] = realloc( a->array, 2 * a->size * sizeof( char[40] ) );
        if ( ( success = tmp != NULL ) )
        {
            a->array = tmp;
            a->size *= 2;
        }
    }

    if ( success )
    { 
        strcpy( a->array[a->used++], element );
    }

    return success;
}

And at last the array srcname

char srcname[40];

must contain a string before passing the array to the function insertArray.

@0___________ I used the approach shown in the code in the question. You may use any value to increase the allocated array.
According to legend, chess was invented by Grand Vizier Sissa Ben Dahir, and given as a gift to King Shirham of India. The king was so delighted that he offered him any reward he requested, provided that it sounded reasonable. The Grand Vizier requested the following: "Just one grain of wheat on the first square of a chessboard. Then put two on the second square, four on the next, then eight, and continue, doubling the number of grains on each successive square, until every square on the chessboard is reached."
Intuitively, King Shirham — just like almost anybody else — underestimated the number of grains and laughed at Sissa because he had asked such a small gift. When he had someone to calculate the total number of grains, it took more than a week before he came back with the solution. King Shirham undoubtedly became very pale when he got the answer: the aggregated number of grains on all squares of a chessboard would be 18.446.744.073.709.551.615 This is the harvest of all the wheat of the world, of several decades.
If we assume that a grain of wheat is 5 mm long, what is the total distance (in kilometers) that we obtain when we put all grains on the chessboard one after the other. Alpha Centauri, the closest star to our solar system, is located at 4.36 light years from Earth. The total length of the grains of wheat sufficiently covers the distance from Earth to this star, and back.

Collectives™ on Stack Overflow

Dynamically growing array of strings in C

2 Answers 2

Comments

6 Comments

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

6 Comments

Related