How to malloc array of strings in a struct - c

Question

I'm trying to malloc array of strings in a struct and it doesn't work well.
I also want to check the size of the arrays but I don't get the right values
what is wrong with my code?
by the way, I know I should free the memory allocation..
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef struct{
char** string;
} Strt;
int main(int agrc, char *argv[]) {
int i;
int size1 = 0, size2 = 0;
char** arrr;
Strt* arr = malloc(sizeof(Strt));
printf("number of arrays: ");
scanf("%d", &size1);
printf("size of each array: ");
scanf("%d", &size2);
arr->string = (char**)malloc(size1 * sizeof(char));
printf("size of string: %d\n", sizeof(arr->string));
for(i = 0; i < size1; i++){
arr->string[i] = (char*)malloc(size2 * sizeof(char));
}
return 0;
}

Answer 1

It looks like you are wanting to allocate for an unknown number of strings. You are thinking correctly that you will want to use a pointer-to-pointer-to char (e.g. char **arr;), but the "train fell off the tracks" so to speak when you went to implement the logic.
Let's look at what you need to do to read and store an unknown number of strings (or any object for that matter). It is a two-step process where you:
allocate storage for pointers, one for each object you wish to store, and
allocate a block of storage for each object, copying the object to the newly allocated block and assigning the beginning address of that block to one of your pointers.
To grow the number of objects stored, you realloc() more pointers and keep going until you run out of objects to store.
When you realloc(), you always use a temporary pointer. Why? Because when (not if) realloc() fails, it returns NULL and if you are simply calling realloc() with the pointer itself, you overwrite the address to the current block of memory with NULL losing the original pointer that can now no longer be freed.
So instead of:
arr = realloc (arr, /* how big */);
You do:
/* always realloc using temp pointer to avoid mem-leak on realloc failure. */
void *tmp = realloc (arr, (nstr + 1) * sizeof *arr); /* realloc pointers */
if (!tmp) { /* VALIDATE EVERY ALLOCATION */
perror ("realloc-tmp");
break;
}
arr = tmp; /* assign reallocated block of pointers to arr */
Now if I understand correctly (though I am not 100% clear on) your need to read and store an unknown number of strings, you do not need a struct. Look at Strt -- it is a single-member struct. The struct serves no purpose there. You simply want a pointer to a block of pointers which you can grow. So char **arr; is all that is needed. Other than that you need a counter to keep track of now many strings are stored, and for the actual read of the string, simply use a fixed size buffer with fgets() or use POSIX getline(). So your setup for beginning to read strings could be:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAXC 1024 /* if you need a constant, #define one (or more) */
int main (void) {
char buf[MAXC], /* buffer to hold each line read */
**arr = NULL; /* pointer-to-pointer-to char */
size_t nstr = 0; /* counter for number of strings stored */
...
Above you will read all input into buf, then you can trim the '\n' included by fgets(), obtaining the length of the input so you can then allocate length + 1 characters of storage for the string (+1 for the nul-terminating character) assigning the beginning address of the new block to the next available pointer. You then copy from buf to your newly allocated block and increment your counter.
(A simple way to trim the '\n' and obtain the length of the input is with strcspn())
Putting those pieces together, your read, trim, reallocation, allocation of the new block and copy to it could be done with:
for (;;) { /* loop continually reading input */
size_t len; /* var to hold length of string after \n removal */
fputs ("enter string (EOF to quit): ", stdout); /* prompt */
if (!fgets (buf, MAXC, stdin)) { /* read line (or EOF) */
puts ("(all done)\n");
break;
}
buf[(len = strcspn (buf, "\r\n"))] = 0; /* trim \n, save len */
/* always realloc using temp pointer to avoid mem-leak on realloc failure. */
void *tmp = realloc (arr, (nstr + 1) * sizeof *arr); /* realloc pointers */
if (!tmp) { /* VALIDATE EVERY ALLOCATION */
perror ("realloc-tmp");
break;
}
arr = tmp; /* assign reallocated block of pointers to arr */
if (!(arr[nstr] = malloc (len + 1))) { /* allocate/validate block for string */
perror ("malloc-arr[nstr]");
break;
}
memcpy (arr[nstr++], buf, len + 1); /* copy string to allocated block */
}
(note: the manual EOF is generated by the user pressing Ctrl + d -- or Ctrl + z on windows)
All that remains is outputting the stored string (or using them however you need) and then freeing the allocated memory:
for (size_t i = 0; i < nstr; i++) { /* loop outputting strings */
puts (arr[i]);
free (arr[i]); /* free string */
}
free (arr); /* free pointers */
}
If you put the whole program together you would have:
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAXC 1024 /* if you need a constant, #define one (or more) */
int main (void) {
char buf[MAXC], /* buffer to hold each line read */
**arr = NULL; /* pointer-to-pointer-to char */
size_t nstr = 0; /* counter for number of strings stored */
for (;;) { /* loop continually reading input */
size_t len; /* var to hold length of string after \n removal */
fputs ("enter string (EOF to quit): ", stdout); /* prompt */
if (!fgets (buf, MAXC, stdin)) { /* read line (or EOF) */
puts ("(all done)\n");
break;
}
buf[(len = strcspn (buf, "\r\n"))] = 0; /* trim \n, save len */
/* always realloc using temp pointer to avoid mem-leak on realloc failure. */
void *tmp = realloc (arr, (nstr + 1) * sizeof *arr); /* realloc pointers */
if (!tmp) { /* VALIDATE EVERY ALLOCATION */
perror ("realloc-tmp");
break;
}
arr = tmp; /* assign reallocated block of pointers to arr */
if (!(arr[nstr] = malloc (len + 1))) { /* allocate/validate block for string */
perror ("malloc-arr[nstr]");
break;
}
memcpy (arr[nstr++], buf, len + 1); /* copy string to allocated block */
}
for (size_t i = 0; i < nstr; i++) { /* loop outputting strings */
puts (arr[i]);
free (arr[i]); /* free string */
}
free (arr); /* free pointers */
}
(note: while you would normally what to allocate blocks of pointers keeping track of the number available and number used and only reallocating when used == available to minimize the number of reallocations needed -- when taking user input, there is no efficiency to be gained due to the delay caused by the user in pecking out the input. But know you can optimize by minimizing the number of reallocations needed)
Example Use/Output
$ ./bin/allocate_p2p
enter string (EOF to quit): My dog
enter string (EOF to quit): has fleas...
enter string (EOF to quit): My cat
enter string (EOF to quit): has none...
enter string (EOF to quit): Lucky cat!
enter string (EOF to quit): (all done)
My dog
has fleas...
My cat
has none...
Lucky cat!
Memory Use/Error Check
In any code you write that dynamically allocates memory, you have 2 responsibilities regarding any block of memory allocated: (1) always preserve a pointer to the starting address for the block of memory so, (2) it can be freed when it is no longer needed.
It is imperative that you use a memory error checking program to ensure you do not attempt to access memory or write beyond/outside the bounds of your allocated block, attempt to read or base a conditional jump on an uninitialized value, and finally, to confirm that you free all the memory you have allocated.
For Linux valgrind is the normal choice. There are similar memory checkers for every platform. They are all simple to use, just run your program through it.
$ valgrind ./bin/allocate_p2p
==16556== Memcheck, a memory error detector
==16556== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==16556== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==16556== Command: ./bin/allocate_p2p
==16556==
enter string (EOF to quit): My dog
enter string (EOF to quit): has fleas...
enter string (EOF to quit): My cat
enter string (EOF to quit): has none...
enter string (EOF to quit): Lucky cat!
enter string (EOF to quit): (all done)
My dog
has fleas...
My cat
has none...
Lucky cat!
==16556==
==16556== HEAP SUMMARY:
==16556== in use at exit: 0 bytes in 0 blocks
==16556== total heap usage: 12 allocs, 12 frees, 2,218 bytes allocated
==16556==
==16556== All heap blocks were freed -- no leaks are possible
==16556==
==16556== For counts of detected and suppressed errors, rerun with: -v
==16556== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
Always confirm that you have freed all memory you have allocated and that there are no memory errors.
Look things over and let me know if I read between the lines correctly as to what you needed, or if I missed. I'm happy to help further if what you need is slightly different. However looking at what you were trying to do, this seemed like what you were aiming at. Let me know if you have further questions.