Storing string input into different arrays in C - c

Question

Hello this brand new noob on C is trying to take a string input of 3 words and store it on 3 different arrays, not 2D nor 3D arrays. For this problem I'm not allow to use any of the string library functions. Basically I'm trying to implement the sscanf function. I created a function that breaks the input into the three words, and stores them in their indicated array. My problem is when I try to print the each of the arrays, for my second array I can't get it to print the word I tried to store in it. I'm probably not storing anything, but I can't find my mistake. Here it's what I have...
#include<stdio.h>
#include<string.h>
void breakUp(char *, char *, char *, char *, int* );
int main()
{
char line[80], comm[10], p1[10], p2[10];
int len, n=0;
printf("Please Enter a command: ");
fgets(line, 80, stdin);
/* get rid of trailing newline character */
len = strlen(line) - 1;
if (line[len] == '\n')
line[len] = '\0';
/* Break up the line */
breakUp(line, comm, p1, p2, &n);
printf ("%d things on this line\n", n);
printf ("command: %s\n", comm);
printf ("parameter 1: %s\n", p1);
printf ("parameter 2: %s\n", p2);
return 0;
}
/*
This function takes a line and breaks it into words.
The orginal line is in the char array str, the first word
will go into the char array c, the second into p1, and the
the third into p2. If there are no words, the corresponding
char arrays are empty. At the end, n contains the number of
words read.
*/
void breakUp(char *str, char *c, char *p1, char *p2, int* n)
{
c[0] = p1[0] = p2[0] = '\0';
p1[0] = '\0';
int j = 0; // str array index
int i = 0; // index of rest of the arrays
n[0] = 0;
// stores first word in array c
while(str[j]!= ' '|| str[j] == '\0')
{
c[i]= str[j];
i++;
j++;
}
// increases n count, moves j into next element
// and sets i back to index 0
if (str[j] == ' '|| str[j] == '\0')
{
c[i] = '\0';
n[0]++;
j++;
i =0;
if( str[j] == '\0')
return;
}
// stores second word in array p1
while(str[j]!= ' '|| str[j] == '\0')
{
p1[i]= str[j];
i++;
j++;
}
// increases n count, moves j into next element
// and sets i back to index 0
if (str[j] == ' '|| str[j] == '\0')
{
p1[i] = '\0';
n[0]++;
j++;
i =0;
if( str[j] == '\0')
return;
}
// stores 3rd word in array p2
while(str[j] != ' ' || str[j] == '\0')
{
p2[i] = str[j];
i++;
j++;
}
// increases n count, moves j into next element
// and sets i back to index 0
if(str[j] == ' ' || str[j] == '\0')
{
p2[i] = '\0';
n[0]++;
if( str[j] == '\0')
return;
}
}
Advanced thanks if any help is provided

Answer 1

while(str[j]!= ' '|| str[j] == '\0')
should be
while(str[j]!= ' '&& str[j]!= '\0')
Same for if statements that check if end of the line was reached. Thanks.

Answer 2

In addition to the comments and answers, there are a few areas where you may be making things harder on yourself than they need to be. First lets look at the return of breakup. Why are you using void? If you need to be able to gauge success/failure of a function, pick a meaningful return type that will provide that information. Here a simple return of int will do (and it also prevents having to pass a pointer to n to update -- you can simply return n) You are free to pass a pointer to n, just note, it cannot be used to provide success/failure information at the time of the call to breakup. A return of n can.
(note: breakup is all lowercase -- leave camelCase variables to java and C++, C traditionally uses all lowercase variable and function names reserving all uppercase for constants and macros)
Second, avoid the use of magic numbers in your code (e.g. 80, 10, etc..). If you need constants, then #define them at the top, or use an enum to define global constants. That way you have a single convenient location at the top of your file to make adjustments and you don't have to go picking through each character array declaration changing magic numbers if you need to change the array sizes, etc. For example, to define the number of words, the command array lengths and the line buffer length, you can simple do:
#define NWRD 3 /* number of words */
#define CLEN 16 /* command length */
#define LLEN 80 /* line buffer len */
or using an enum:
enum { NWRD = 3, CLEN = 16, LLEN = 80 }; /* constants */
Now for the content of breakup, you are free to duplicate the code blocks for reading each word 3 separate times, but you can get a little smarter about it and realize you are already passing pointers to 3 character arrays to breakup, why not just use an array of pointers initialized to { c, p1, p2 } and then just write a single block of code to pick out each word from str? It's just a shorter way of skinning-the-cat so to speak. That way, instead of having to reference c, p1, p2, you can simply loop over arr[0], arr[1], arr[2], where arr[0] = c, arr[1] = p1, arr[2] = p2;.
For example, with your new declaration for breakup being:
int breakup (char *str, char *c, char *p1, char *p2);
within breakup you could assign the array of pointers as follows:
char *arr[] = { c, p1, p2 };
Then you can simply add all characters in the first word to arr[0], all chars in the second to arr[1], and so on which will in-turn fill c, p1, p2. That looks like something that could be handled in a nice single loop...
All you need do now is figure out a way of adding each character to each word, checking for spaces (or multiple spaces and tabs), making sure you nul-terminate each word, make sure you only fill three words -- and no more, and finally return the number of words you filled.
Without belaboring each point, you could shorten breakup to something like the following:
int breakup (char *str, char *c, char *p1, char *p2)
{
char *arr[] = { c, p1, p2 }; /* assign c, p1, p2 to arr */
int cidx = 0, n = 0; /* character index & n */
for (; n < NWRD; str++) { /* loop each char while n < NWRD */
if (*str == ' ' || *str == '\t') { /* have space or tab? */
if (*arr[n]) { /* have chars in arr[n]? */
arr[n++][cidx] = 0; /* nul-terminate arr[n] */
cidx = 0; /* zero char index */
}
}
else if (*str == '\n' || !*str) { /* reached '\n' or end of str? */
arr[n++][cidx] = 0; /* nul-terminate arr[n] */
break; /* bail */
}
else
arr[n][cidx++] = *str; /* assign char to arr[n] */
}
return n;
}
note: breakup tests the first character in each word to determine if you have started filling the word (to allow you to skip over multiple spaces or tabs), so you either need to insure you initialize all strings in main, or you could do it at the top of breakup as well. In main, you can simply initialize your character arrays when you declare them, e.g.
char line[LLEN] = "", comm[CLEN] = "", p1[CLEN] = "", p2[CLEN] = "";
(note: it is good practice to initialize all variables when you declare them).
You may want to also add a few additional validations when you are reading line to insure it isn't empty before passing it to breakup. You can do that by simply adding validations at the time line is read by fgets, example:
printf ("please enter a command: "); /* prompt & get line */
if (!fgets (line, LLEN, stdin) || !*line || *line == '\n') {
fprintf (stderr, "error: input empty or user canceled.\n");
return 1;
}
which checks that the first character in line is not the nul-character (empty-string) or that the first character is '\n' (empty-line).
Putting it altogether in a short example, you could do something like the following:
#include <stdio.h>
enum { NWRD = 3, CLEN = 16, LLEN = 80 }; /* constants */
int breakup (char *str, char *c, char *p1, char *p2)
{
char *arr[] = { c, p1, p2 }; /* assign c, p1, p2 to arr */
int cidx = 0, n = 0; /* character index & n */
for (; n < NWRD; str++) { /* loop each char while n < NWRD */
if (*str == ' ' || *str == '\t') { /* have space or tab? */
if (*arr[n]) { /* have chars in arr[n]? */
arr[n++][cidx] = 0; /* nul-terminate arr[n] */
cidx = 0; /* zero char index */
}
}
else if (*str == '\n' || !*str) { /* reached '\n' or end of str? */
arr[n++][cidx] = 0; /* nul-terminate arr[n] */
break; /* bail */
}
else
arr[n][cidx++] = *str; /* assign char to arr[n] */
}
return n;
}
int main (void) {
char line[LLEN] = "", comm[CLEN] = "", p1[CLEN] = "", p2[CLEN] = "";
int n = 0;
printf ("please enter a command: "); /* prompt & get line */
if (!fgets (line, LLEN, stdin) || !*line || *line == '\n') {
fprintf (stderr, "error: input empty or user canceled.\n");
return 1;
}
if ((n = breakup (line, comm, p1, p2)) != NWRD) { /* call breakup */
fprintf (stderr, "error: %d words found\n", n);
return 1;
}
printf ("command : %s\nparameter 1: %s\nparameter 2: %s\n",
comm, p1, p2);
return 0;
}
Example Use/Output
$ ./bin/breakup
please enter a command: dogs have fleas
command : dogs
parameter 1: have
parameter 2: fleas
$ ./bin/breakup
please enter a command: dogs have
error: 2 words found
$ ./bin/breakup
please enter a command: dogs have lots of fleas
command : dogs
parameter 1: have
parameter 2: lots
$ ./bin/breakup
please enter a command: dogs have fleas for sale
command : dogs
parameter 1: have
parameter 2: fleas
Look things over and make sure you understand what is happening. Being new. the array of pointers char *arr[] = { c, p1, p2 }; may have you scratching your head, but it is doing nothing more than creating 3 pointers arr[0], arr[1], arr[2] and assigning arr[0] = c; arr[1] = p1, arr[2] = p2; (just as you would use any pointer, say char *p = c, only you are using arr[0] instead of p to allow yourself to loop over each pointer.
Beyond that it is all fairly basic. But the time in now to ask questions to make sure you understand it going forward.