Thread: how to parse a string

somefile : anotherfile

and

somefile:anotherfile

I would like to have a function that would work for both of these string

I want to separate this string into

somefile
:
anotherfile

what should I use?

if I use strtok(line, ":"), then it wouldn't work right?

Why wouldn't that work? You can do something like this:

Code:

char *str;
while (str != NULL) {
  str = strtok(line, ":"); // <- this will store "somefile"
  str = strtok(NULL, ":"); // <- now str will contain "anotherfile"
}

I havent seen strtok used much but I'm pretty sure that's how you would use it.

but one gives me somefile with an extra space:

somefile_

and the other one just gives me

somefile

right?

oh I think you're right.. now comes another question, how do I check that after some string, there is a : ?

scanf("%s:%s", somevar, anothervar);

would do that job for you just fine.

If you're reading from files, use fscanf.

Have you looked into strchr?

with this code:

Code:

char *str;
while (str != NULL) {
  str = strtok(line, ":"); // <- this will store "somefile"
  str = strtok(NULL, ":"); // <- now str will contain "anotherfile"
}

why does the first time we should pass line to the strtok and the rest not?

Easy answer: because that's the way strtok works. Slightly less easy answer: The idea behind the NULL pointer is that strtok saves where the last search ended, so that it can resume where it left off. If you pass in a string, it's going to assume that you want to start over.

Code:

char* pch = strtok(line, ":");
	  if (pch == NULL){
	    ..............
	  }
	
      	  int h;
          for (h = 0; pch != NULL; h++){
	     if (h == 0){
	       if (strtok(pch, " ") != NULL)
		 ..........
	       else
	        ...........
		
		
	     }
	     else{
	      ............
	     }
           printf("PCH BEFORE IS %s\n", pch);
	    pch = strtok(line, " ");
	    printf("PCH IS %s\n", pch);
          }
	   
       }

if that's so what's wrong with this code

when it tries to

process through this file

Code:

haha : hehe
	........

hehe :
	............

First of all, omitting lines for the sake of brevity is not very helpful. It begs the question what are you actually doing? Instead, consider providing a reasonably sized, complete example of the problem you are attempting to solve. For example, these are all good questions. I hope this advice helps you the next time you need to ask something.

strtok is an okay solution for simple patterns like this I suppose, though there might be issues, especially if you have blank fields (lines with just ":"). If that is the case, you might want to look toward sscanf or strcspn for a parser.

Though, it appears you are passing strtok the token instead of something like NULL to keep searching in the same place or a different delimeter. As in real life, if you keep looking in the same place for the same thing and it ain't there, you'll never find it.

Code:

char * pch = strtok( haystack, needle );  
if ( pch != NULL )
  pch = strtok( pch, needle ); 
  /** woops, probably not going to find the same token again **/

well what I am trying to do here is this:

say I have the following string

cat : dog mouse mice hot

I want to parse

cat dog mouse mice and hot

Fair enough. You were pretty close with your attempt. Seems like with some slight changes you'd be on your way. Notice that I added a space in the delimiter string.

Code:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main ( void )
{
    char parse[] = "cat : dog mouse mice hot";
    char * tok = NULL;

    tok = strtok( parse, ": " );
    if( tok != NULL ) {
        puts( tok );
        while ( ( tok = strtok( NULL, ": " ) ) != NULL ) {
            puts( tok );
        }
    }
    
    return 0;
}

cat
dog
mouse
mice
hot

will this code work too for :

cat:dog mouse mice hot

because I want to get cat without the space

cat only not cat_

Easy answer: take your program, remove the space and see what happens.
Other easy answer: yes, since strtok just looks for one of the characters in the delimiter string, not the whole string.