storing char* array in C - c

Question

I'm trying to create and store a char* array.
So, first I tried this:
int main() {
char* values[3];
values[0] = "Hello";
values[1] = "Mew meww";
values[2] = "Miau miau =3";
for(int i=0; i<sizeof(values); i++)
printf("%s", values[i]);
}
it works with this OUTPUT:
Hello
Mew Mew
Miau miau =3
If i try:
printf("%s", "Tamaño del diccionario: ");
int tam;
scanf("%i", &tam);
char* dic[tam];
Word words[tam];
for(int i=0; i<tam; i++)
{
printf("Palabra %d: ",(i+1));
scanf("%32s", &dic[i]);
}
for(int i=0; i<tam; i++)
{
printf("%s",dic[i]);
printf("\n");
}
Show non-legible stuff like "0xassdfsdf"
What can I do to store it right in memory?

Answer 1

#include <stdio.h>
#include <stdlib.h>
int main(){
char* values[3];
values[0] = "Hello";
values[1] = "Mew meww";
values[2] = "Miau miau =3";
for(int i=0; i<sizeof(values)/sizeof(*values); i++)
printf("%s\n", values[i]);
printf("%s", "Size for dictionary: ");
int tam;
scanf("%i", &tam);
char *dic[tam];
for(int i=0; i<tam; i++){
printf("Palabra %d: ",(i+1));
dic[i] = malloc(33);
scanf("%32s", dic[i]);
}
for(int i=0; i<tam; i++){
printf("%s\n", dic[i]);
free(dic[i]);
}
return 0;
}

Answer 2

One problem is
scanf("%32s", &dic[i]);
which should be
scanf("%32s", dic[i]);
because the array contains pointers to storage, not storage itself, and what you should pass to scanf is this pointer. Indeed, a char* is just a 4-byte pointer. The array char* dic[tam] contains some such pointers, so that dic[0] is a 4-byte pointer to char, and &dic[0] is the address of this pointer. Then your
scanf("%32s", &dic[i]);
just overwrites this pointer plus corrupts memory after it.
Another problem is that you do not initialize the array, so it does not point to any storage.
char* dic[tam];
here the array contains pointers to random places in memory.
scanf("%32s", &dic[i]);
most probably this fails at all. So in your printf you print pointers to random places in memory.
A (bad) solution is:
for(int i=0; i<tam; i++)
{
printf("Palabra %d: ",(i+1));
dic[i] = new char [1000]; // here you assign it some storage
scanf("%32s", dic[i]); // NOT &dic[i]
}
or (slightly better)
for(int i=0; i<tam; i++)
{
printf("Palabra %d: ",(i+1));
char buffer [1000]; // temporal storage arguably large enough
scanf("%32s", buffer);
dic[i] = new char [strlen (buffer) + 1]; // storage of the right size to hold the string
strcpy (dic[i], buf); // copy the data to this new storage
}

Answer 3

The key thing to understand for both of your examples is that a char * value stores the address of a byte in memory. By convention, C strings are represented as a pointer to the first byte of the string, with a null byte marking the end. When you assigned constant strings into your array, the compiler allocated the necessary memory and placed the pointers into your array, but when you are not using constants it is your responsibility to allocate the buffer to store the string, and then store that pointer in the array yourself.
In your second example you have allocated storage for several pointers to char, but you have not made those pointers refer to valid buffers, so accessing them with either return garbage or crash the program. There are (at least) two ways to address this: either allocate a fixed-size buffer on the stack and store your data there, or dynamically allocate memory from the heap using malloc.
The former has the advantage of handling the deallocation of the buffers automatically, but requires you to decide at compile time how much memory to allocate for each string:
char* dic[tam];
char buf[tam * 32]; // allocate 32 bytes per element.
for (int i = 0; i < tam; i++) {
// Make the pointers in ``dic`` refer to 32-byte offsets into the buffer.
dic[tam] = &(buf[tam * 32]);
}
You can also allocate dynamically using malloc. You could actually allocate one big tam * 32 buffer this way too, but for the sake of example here's how to allocate a separate buffer for each element:
char* dic[tam];
for (int i = 0; i < tam; i++) {
// Allocate 32 bytes per element.
// (This value can be decided at runtime, if you want.)
dic[tam] = malloc(32);
}
But since this uses malloc you need to be sure to clean up this memory before you return to avoid a memory leak. e.g. at the end of your routine:
for (int i = 0; i < tam; i++) {
// de-allocate the buffer we allocated earlier
free(dic[tam]);
}
(This method of calling malloc multiple times in a loop may also cause memory fragmentation if you do it a lot, but that's an advanced topic not worth worrying about for a small program.)