strtok:

#include <string.h>

char *strtok(char *str, const char *delim);

char *strtok_r(char *str, const char *delim, char **saveptr);

功能：分解字符串为一组标记串。str为要分解的字符串，delim为分隔符字符串。

说明：首次调用时，str必须指向要分解的字符串，随后调用要把s设成NULL。

     strtok在str中查找包含在delim中的字符并用NULL('/0')来替换，直到找遍整个字符串。

     返回指向下一个标记串。当没有标记串时则返回空字符NULL。

实例：用strtok来判断ip地址是否合法：ip_strtok.c：

[c-sharp] view plaincopy

//ip_strtok.c

#include <stdio.h>

#include <string.h>

int main(int argc, char **argv)

{

  char temp_buf[] = {};

  char p_temp[];

  char *p=NULL;

  char *t = ".";

  int m,n,i;

  int j=,s=;  

  if(argc!=)

  {

    printf("param must 2/n");

    return -;

  }

  strcpy(temp_buf, argv[]);

  for(i=; i<strlen(temp_buf);i++)

  {

    if(temp_buf[i] == *t)j++;

    if(temp_buf[i] == *t && (temp_buf[i+]>=''&&temp_buf[i+]<=''))

    {

      s++;

    }

  }

  if(j!= || j!=s)

  {

    printf("ip param format error/n");

    return -;

  }

  p = strtok(temp_buf, t);  

  while(p!=NULL)

  {

     strcpy(p_temp, p);

     printf("%s /n", p_temp);

     for(n=; n<strlen(p_temp);n++)

     {

       if(!(p_temp[n]>=''&&p_temp[n]<=''))

       {

         printf("ip param error/n");

         return -;

       }

     }  

     m = atoi(p_temp);

     if(m>)

     {

       printf("ip invalid /n");

       return -;

     }  

     p=strtok(NULL, ".");

     printf("p = %s/n",p);

  }

  printf("ok! ip correct! ip=%s/n", argv[]);

  return ;

}

编译运行：

[root@localhost liuxltest]# uname -r

2.6.

[root@localhost liuxltest]# gcc -Wall ip_strtok.c -o ip_strtok

[root@localhost liuxltest]# ./ip_strtok 172.18.4.255

p = 

p = 

p = 

p = (null)

ok! ip correct! ip=172.18.4.255

[root@localhost liuxltest]# ./ip_strtok 172.18.

ip param format error

strtok实现函数：

xl_strtok.c

[c-sharp] view plaincopy

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

char *xl_strtok(char *str, const char *delim);

int main(int argc, char **argv)

{

   if(argc != )

   {

       printf("param must be 3 /n");

       return -;

   }  

       char *temp;

       char *p_temp;

   char *p;

   temp=(char *)malloc();

   p_temp=(char *)malloc();

   strcpy(temp, argv[]);

   strcpy(p_temp, argv[]);

   printf("temp = %s /n",temp);

   printf("p_temp = %s /n", p_temp);

       p = xl_strtok(temp, p_temp);

       printf("%s/n", p);

       return ;

}

char *xl_strtok(char *s, const char *dm)

{

       static char *last;

       char *tok;

       if(s == NULL)

               s = last;

       if(s == NULL)

               return NULL;

       tok = s;

       while (*s != '/0')

   {

               while (*dm)

       {

                       if (*s == *dm)

           {

                               *s = '/0';

                               last = s + ;

                               break;

                       }

                       s++;

               }

       }

       return tok;

}

strtok源码：

/*********************************************************************/

/***

*strtok.c - tokenize a string with given delimiters

*

*       Copyright (c) Microsoft Corporation. All rights reserved.

*

*Purpose:

*       defines strtok() - breaks string into series of token

*       via repeated calls.

*

*******************************************************************************/

#include <cruntime.h>

#include <string.h>

#ifdef _SECURE_VERSION

#include <internal.h>

#else  /* _SECURE_VERSION */

#include <mtdll.h>

#endif  /* _SECURE_VERSION */

/***

*char *strtok(string, control) - tokenize string with delimiter in control

*

*Purpose:

*       strtok considers the string to consist of a sequence of zero or more

*       text tokens separated by spans of one or more control chars. the first

*       call, with string specified, returns a pointer to the first char of the

*       first token, and will write a null char into string immediately

*       following the returned token. subsequent calls with zero for the first

*       argument (string) will work thru the string until no tokens remain. the

*       control string may be different from call to call. when no tokens remain

*       in string a NULL pointer is returned. remember the control chars with a

*       bit map, one bit per ascii char. the null char is always a control char.

*

*Entry:

*       char *string - string to tokenize, or NULL to get next token

*       char *control - string of characters to use as delimiters

*

*Exit:

*       returns pointer to first token in string, or if string

*       was NULL, to next token

*       returns NULL when no more tokens remain.

*

*Uses:

*

*Exceptions:

*

*******************************************************************************/

#ifdef _SECURE_VERSION

#define _TOKEN *context

#else  /* _SECURE_VERSION */

#define _TOKEN ptd->_token

#endif  /* _SECURE_VERSION */

#ifdef _SECURE_VERSION

char * __cdecl strtok_s (

       char * string,

       const char * control,

       char ** context

       )

#else  /* _SECURE_VERSION */

char * __cdecl strtok (

       char * string,

       const char * control

       )

#endif  /* _SECURE_VERSION */

{

       unsigned char *str;

       const unsigned char *ctrl = control;

       unsigned char map[];

       int count;

#ifdef _SECURE_VERSION

       /* validation section */

       _VALIDATE_RETURN(context != NULL, EINVAL, NULL);

       _VALIDATE_RETURN(string != NULL || *context != NULL, EINVAL, NULL);

       _VALIDATE_RETURN(control != NULL, EINVAL, NULL);

       /* no static storage is needed for the secure version */

#else  /* _SECURE_VERSION */

       _ptiddata ptd = _getptd();

#endif  /* _SECURE_VERSION */

       /* Clear control map */

       for (count = ; count < ; count++)

               map[count] = ;

       /* Set bits in delimiter table */

       do {

               map[*ctrl >> ] |= ( << (*ctrl & ));

       } while (*ctrl++);

       /* Initialize str */

       /* If string is NULL, set str to the saved

        * pointer (i.e., continue breaking tokens out of the string

        * from the last strtok call) */

       if (string)

               str = string;

       else

               str = _TOKEN;

       /* Find beginning of token (skip over leading delimiters). Note that

        * there is no token iff this loop sets str to point to the terminal

        * null (*str == '/0') */

       while ( (map[*str >> ] & ( << (*str & ))) && *str )

               str++;

       string = str;

       /* Find the end of the token. If it is not the end of the string,

        * put a null there. */

       for ( ; *str ; str++ )

               if ( map[*str >> ] & ( << (*str & )) ) {

                       *str++ = '/0';

                       break;

               }

       /* Update nextoken (or the corresponding field in the per-thread data

        * structure */

       _TOKEN = str;

       /* Determine if a token has been found. */

       if ( string == str )

               return NULL;

       else

               return string;

}