scanf strings messed up - c

Question

struct dict {
int len;
char (*dict0)[MAX_WORD_LEN+1];
char (*dict1)[MAX_WORD_LEN+1];
};
/* the memory allocation */
void createDict(struct dict* myDict)
{
(*myDict).dict0 = malloc((*myDict).len*sizeof(char));
(*myDict).dict1 = malloc((*myDict).len*sizeof(char));
if(((*myDict).dict0==0)||((*myDict).dict1==0))
exit(1);
}
for(int i = 0; i < words; i++)
{
scanf("%s", p_diction->dict0[i]);
scanf("%s", p_diction->dict1[i]);
}
for(int i=0; i<words; i++)
{
printf("%s ", &p_diction->dict0[i]);
printf("%s\n", &p_diction->dict1[i]);
}
p_diction is a pointer to a dict type.
I set words to 11 and input the following:
one lo
two ba
three li
day night
work eat
great terrible
terrible disaster
A a
start delay
finish never
I you
But when I printf to check the strings, they print the following:
one ree
two y
three rk
day eat
work rrible
great terrible
terrible art
A nish
start delay
finish never
I you
Any idea as to why the first scanf reads it perfectly, while the second one just reads random stuff from words that will come later?

Answer 1

It looks like you are using a one-dimensional array to hold multiple strings(words) which is possible if you end each string(word) with a unique character that signifies the end of a word. But it wouldn't be possible to do that using the vanilla functions scanf() and printf() you would have to write your own. For example lets say you end each word with a #. The following loop would print all the words to your screen.
int i = 0;
while((*myDict).dict0[i] != '\0')//While index dose not point to end of array
{
for(; (*myDict).dict0[i] != '#'; i++)//Print one word a single character at a time
{
printf("%c", (*myDict).dict0[i]);
}
printf("\n"); i++;//Print a newline after the word and then increase the index by one
//so that it does not point to '#'.
}
But you could also make your dict0 and dict1 arrays into arrays of pointers in which each element is a pointer that points to a single word.

Answer 2

You're redeclaring i and you don't need to(for the printf loop). for the second loop i already exists so i=0 is enough to 'reinit' the variable.
About the read loop, scanf is 'safe' if you do separation between words with enter/return. If you are separating them with spaces scanf is not a good option. The second scanf is looking for that enter/return, if you don't give it by the stdin it will fail and it will probably storing garbage until it finds the enter/return(\n).
And one more thing, how are you declaring pdiction?
If you do:
struct dict *pdiction = malloc(sizeof(struct dict));
You access its 'inner' variables with:
pdiction->len = 10; /*Setting len to 10*/
But if you declare it, inside the same function as the read/write loop, like this:
struct dict pdiction;
You access the 'inner' variables this way:
pdiction.len = 10;
The second way is how C structures are normally accessed. The so called dot notation.
The first way is kinda like an evoluiton of C: It was so common to use the 'pointed by in the field' for pointers to structures that C gives you a better/easier/more readable way to do it: the arrow notation.
What I've wrote in the first case is exactly the same as:
(*pdiction).len = 10; /*The (structure) pointed by pdiction in the field len*/
So be careful with that.
Just to finish, I think that you've done that on purpose, but the printf is probably printing memory addresses and not the actual strings because you are using the memory address 'selector' ampersand.
[EDIT] - After seing your edit I can see one possible mistake. If in your struct you have declared the strings with a static value:
char (*dict0)[MAX_WORD_LEN+1];
char (*dict1)[MAX_WORD_LEN+1];
You don't need to 'realloc' space for them.
What you need is to have a vector of strings or a vector of dictionaries.
The access pdiction->dict[i] is only a char.
If you want a vector instead, you need to do change your allocation.
I would do it by declaring only pointers in the struct and doing the vector allocation later instead of having a vector of dicts(structs).
You can do that by changing your struct to this:
struct dict {
int len;
char **dict0;
char **dict1;
};
And then you'll have to alloc your vectors in the function:
pdiciton->dict0 = malloc(NUMBER_OF WORDS * sizeof (char*));
for(i=0;i<NUMBER_OF_WORDS;i++)
pdiction->dict0[i] = malloc(MAXIMUM_SIZE_OF_A_WORD*sizeof(char));
The same for dict1.
This might seem odd, but if you think about it is actually logic: if a string is a vector of characters, a vector of strings is a matrix of characters.
The problem with scanf though, seems the same: It is safe to use with enter/return but not with spaces. Try to insert all your data with an enter/return next instead of spaces and see if it works.
Hope this helps.