首页 > 编程语言 > 详细

C 语言字符串处理函数实现合集

时间：2015-06-17 21:30:57      阅读：266      评论：0      收藏：0      [点我收藏+]

其中包括：strcpy(char *, char *),strncpy();strcat();strncat();strcmp();strncmp();strchr();strrchr();strlen();

strdup();strspn();strpbrk();strtok(); memset();memcpy();memmove();memcmp();memscan();strstr();

_strupr_();_strlen_();_strsplit_();_hex2dec_();_str2hex_();_str2dec_();

 

[cpp] view plaincopy
  1. /*=========================================================================  
  2.   工程名称：C语言  
[cpp] view plaincopy
  1. 组成文件：string_lib.c  
  2. 功能描述：常用C库函数的C实现  
  3. 程序分析：  
  4. 维护记录：  
[cpp] view plaincopy
  1. =========================================================================*/  
  2.   
  3. char * ___strtok = NULL;  
  4.   
  5.   
  6. char * strcpy(char * dest,const char *src)  
  7. {  
  8.     char *tmp = dest;  
  9.   
  10.     while ((*dest++ = *src++) != ‘\0‘)  
  11.         /* nothing */;  
  12.     return tmp;  
  13. }  
  14.   
  15.   
  16.   
  17. char * strncpy(char * dest,const char *src,size_t count)  
  18. {  
  19.     char *tmp = dest;  
  20.   
  21.     while (count-- && (*dest++ = *src++) != ‘\0‘)  
  22.         /* nothing */;  
  23.   
  24.     return tmp;  
  25. }  
  26.   
  27.   
  28.   
  29. char * strcat(char * dest, const char * src)  
  30. {  
  31.     char *tmp = dest;  
  32.   
  33.     while (*dest)  
  34.         dest++;  
  35.     while ((*dest++ = *src++) != ‘\0‘)  
  36.         ;  
  37.     return tmp;  
  38. }  
  39.   
  40.   
  41.   
  42. char * strncat(char *dest, const char *src, size_t count)  
  43. {  
  44.     char *tmp = dest;  
  45.   
  46.     if (count)   
  47.     {  
  48.         while (*dest)  
  49.             dest++;  
  50.         while ((*dest++ = *src++))   
  51.         {  
  52.             if (--count == 0)   
  53.             {  
  54.                 *dest = ‘\0‘;  
  55.                 break;  
  56.             }  
  57.         }  
  58.     }  
  59.     return tmp;  
  60. }  
  61.   
  62.   
  63. int strcmp(char *s1, char *s2)  
  64. {  
  65.     while(*s1 && *s2)  
  66.     {  
  67.         if(*s1 - *s2)  
  68.             return (*s1 - *s2);  
  69.         s1++;  
  70.         s2++;  
  71.     }  
  72.     if(*s1 != 0)  
  73.         return 1;  
  74.     else  
  75.         return -1;  
  76.     return 0;  
  77. }  
  78.   
  79.   
  80. int strncmp(char *s1, char *s2, int len)  
  81. {  
  82.     while(len--)  
  83.     {  
  84.         if(*s1 && *s2)  
  85.         {  
  86.             if(*s1 - *s2)  
  87.                 return (*s1 - *s2);  
  88.             s1++;  
  89.             s2++;  
  90.         }  
  91.         else  
  92.         {  
  93.             if(*s1 || *s2)  
  94.                 return(*s1? *s1: *s2);  
  95.         }  
  96.     }  
  97.     return 0;  
  98. }  
  99.   
  100.   
  101. char * strchr(const char * s, int c)  
  102. {  
  103.     for(; *s != (char) c; ++s)  
  104.         if (*s == ‘\0‘)  
  105.             return NULL;  
  106.     return (char *) s;  
  107. }  
  108.   
  109.   
  110. char * strrchr(const char * s, int c)  
  111. {  
  112.        const char *p = s + strlen(s);  
  113.        do   
  114.        {  
  115.                 if (*p == (char)c)  
  116.             return (char *)p;  
  117.        }   
  118.        while (--p >= s);  
  119.        return NULL;  
  120. }  
  121.   
  122.   
  123. size_t strlen(const char * s)  
  124. {  
  125.     const char *sc;  
  126.   
  127.     for (sc = s; *sc != ‘\0‘; ++sc)  
  128.         /* nothing */;  
  129.     return sc - s;  
  130. }  
  131.   
  132.   
  133. char * strdup(const char *s)  
  134. {  
  135.     char *new;  
  136.   
  137.     if ( (s == NULL) || ((new = malloc (strlen(s) + 1)) == NULL) )  
  138.      {  
  139.         return NULL;  
  140.     }  
  141.   
  142.     strcpy (new, s);  
  143.     return new;  
  144. }  
  145.   
  146.   
  147. size_t strspn(const char *s, const char *accept)  
  148. {  
  149.     const char *p;  
  150.     const char *a;  
  151.     size_t count = 0;  
  152.   
  153.     for (p = s; *p != ‘\0‘; ++p)   
  154.     {  
  155.         for (a = accept; *a != ‘\0‘; ++a)   
  156.         {  
  157.             if (*p == *a)  
  158.                 break;  
  159.         }  
  160.         if (*a == ‘\0‘)  
  161.             return count;  
  162.               
  163.         ++count;  
  164.     }  
  165.   
  166.     return count;  
  167. }  
  168.   
  169.   
  170. char * strpbrk(const char * cs,const char * ct)  
  171. {  
  172.     const char *sc1,*sc2;  
  173.   
  174.     for( sc1 = cs; *sc1 != ‘\0‘; ++sc1)   
  175.     {  
  176.         for( sc2 = ct; *sc2 != ‘\0‘; ++sc2)   
  177.         {  
  178.             if (*sc1 == *sc2)  
  179.                 return (char *) sc1;  
  180.         }  
  181.     }  
  182.     return NULL;  
  183. }  
  184.   
  185.   
  186. char * strtok(char * s,const char * ct)  
  187. {  
  188.     char *sbegin, *send;  
  189.   
  190.     sbegin  = s ? s : ___strtok;  
  191.     if (!sbegin)   
  192.     {  
  193.         return NULL;  
  194.     }  
  195.     sbegin += strspn(sbegin,ct);  
  196.     if (*sbegin == ‘\0‘)   
  197.     {  
  198.         ___strtok = NULL;  
  199.         return( NULL );  
  200.     }  
  201.     send = strpbrk( sbegin, ct);  
  202.     if (send && *send != ‘\0‘)  
  203.         *send++ = ‘\0‘;  
  204.     ___strtok = send;  
  205.     return (sbegin);  
  206. }  
  207.   
  208.   
  209. void * memset(void * s,char c,size_t count)  
  210. {  
  211.     char *xs = (char *) s;  
  212.   
  213.     while (count--)  
  214.         *xs++ = c;  
  215.   
  216.     return s;  
  217. }  
  218.   
  219.   
  220. void * memcpy(void * dest,const void *src,size_t count)  
  221. {  
  222.     char *tmp = (char *) dest, *s = (char *) src;  
  223.   
  224.     while (count--)  
  225.         *tmp++ = *s++;  
  226.   
  227.     return dest;  
  228. }  
  229.   
  230.   
  231. void * memmove(void * dest,const void *src,size_t count)  
  232. {  
  233.     char *tmp, *s;  
  234.   
  235.     if (dest <= src)   
  236.     {  
  237.         tmp = (char *) dest;  
  238.         s = (char *) src;  
  239.         while (count--)  
  240.             *tmp++ = *s++;  
  241.     }  
  242.     else   
  243.     {  
  244.         tmp = (char *) dest + count;  
  245.         s = (char *) src + count;  
  246.         while (count--)  
  247.             *--tmp = *--s;  
  248.     }  
  249.   
  250.     return dest;  
  251. }  
  252.   
  253.   
  254. int memcmp(const void * cs,const void * ct,size_t count)  
  255. {  
  256.     const unsigned char *su1, *su2;  
  257.     signed char res = 0;  
  258.   
  259.     for( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)  
  260.         if ((res = *su1 - *su2) != 0)  
  261.             break;  
  262.     return res;  
  263. }  
  264.   
  265.   
  266. /* 
  267.  * find the first occurrence of byte ‘c‘, or 1 past the area if none 
  268.  */  
  269. void * memscan(void * addr, int c, size_t size)  
  270. {  
  271.     unsigned char * p = (unsigned char *) addr;  
  272.   
  273.     while (size) {  
  274.         if (*p == c)  
  275.             return (void *) p;  
  276.         p++;  
  277.         size--;  
  278.     }  
  279.     return (void *) p;  
  280. }  
  281.   
  282.   
  283. char * strstr(const char * s1,const char * s2)  
  284. {  
  285.     int l1, l2;  
  286.   
  287.     l2 = strlen(s2);  
  288.     if (!l2)  
  289.         return (char *) s1;  
  290.     l1 = strlen(s1);  
  291.     while (l1 >= l2)   
  292.     {  
  293.         l1--;  
  294.         if (!memcmp(s1,s2,l2))  
  295.             return (char *) s1;  
  296.         s1++;  
  297.     }  
  298.     return NULL;  
  299. }  
  300.   
  301. //=============================================================  
  302. // 语法格式：    char *_strupr_(char *Str)  
  303. // 实现功能：    将字符串转换为全大写  
  304. // 参数：      Str -   输入字符串首地址  
  305. // 返回值：     输出字符串首地址  
  306. // 注意:      该程序将直接修改原始字符串  
  307. //=============================================================  
  308. char *_strupr_(char *Str)  
  309. {  
  310.     char *cp;  
  311.     cp = Str;  
  312.     while (*cp != 0)  
  313.     {  
  314.         if (*cp >= ‘a‘ && *cp <= ‘z‘ )  
  315.         {  
  316.             *cp -=  ‘a‘ - ‘A‘;  
  317.         }  
  318.         cp++;  
  319.     }  
  320.     return Str;  
  321. }  
  322.   
  323. //=============================================================  
  324. // 语法格式：    int _strlen_(char *s)  
  325. // 实现功能：    求取字符串长度  
  326. // 参数：      s   -   输入字符串首地址  
  327. // 返回值：     字符串长度  
  328. //=============================================================  
  329. int _strlen_(char *s)  
  330. {  
  331.     int i = 0;  
  332.     while(*s)  
  333.     {  
  334.         i++;  
  335.         s++;  
  336.     }  
  337.     return i;  
  338. }  
  339.   
  340.   
  341. //=============================================================  
  342. // 语法格式：    int _strsplit_(char *sour, char *splstr, char *dest[])  
  343. // 实现功能：    字符串分割  
  344. // 参数：      sour    -   原始字符串首地址  
  345. //              splstr  -   分割字符串  
  346. //              dest[]  -   分割之后的每个字符串的首地址  
  347. // 返回值：     分割之后的字符串数量  
  348. //=============================================================  
  349. int _strsplit_(char *sour, char *splstr, char *dest[])  
  350. {  
  351.     int i = 0;  
  352.     int len;  
  353.     char *cp;  
  354.     if(*splstr == 0)  
  355.         return 0;  
  356.   
  357.     cp = sour;  
  358.   
  359.     dest[i] = cp;  
  360.     len = _strlen_(splstr);  
  361.     while(*sour)  
  362.     {  
  363.         if(*sour == *splstr)  
  364.         {  
  365.             if(_strncmp_(sour, splstr, _strlen_(splstr)) == 0)  
  366.             {  
  367.                 i++;  
  368.                 sour += len - 1;  
  369.                 *cp++ = 0;  
  370.                 dest[i] = cp;  
  371.             }  
  372.         }  
  373.         else cp++;  
  374.        sour++;  
  375.     }  
  376.     return (i + 1);  
  377. }  
  378.   
  379. //=============================================================  
  380. // 语法格式：    unsigned int _hex2dec_(unsigned int Binary)  
  381. // 实现功能：    二进制转BCD码(仅转换输入数据的低16bit)  
  382. // 参数：      Binary  -   输入数据  
  383. // 返回值：     BCD码  
  384. //=============================================================  
  385. unsigned int _hex2dec_(unsigned int Binary)  
  386. {  
  387.     unsigned int ulRet = 0;  
  388.     Binary &= 0xffff;  
  389.     while(Binary >= 10000)  
  390.     {  
  391.         ulRet += 10000;  
  392.         Binary -= 10000;  
  393.     }  
  394.     while(Binary >= 1000)  
  395.     {  
  396.         ulRet += 0x1000;  
  397.         Binary -= 1000;  
  398.     }  
  399.     while(Binary >= 100)  
  400.     {  
  401.         ulRet += 0x0100;  
  402.         Binary -= 100;  
  403.     }  
  404.     while(Binary >= 10)  
  405.     {  
  406.         ulRet += 0x0010;  
  407.         Binary -= 10;  
  408.     }  
  409.     ulRet += Binary;  
  410.     return (ulRet);  
  411. }  
  412.   
  413. //=============================================================  
  414. // 语法格式：    int _str2hex_(char *s)  
  415. // 实现功能：    将一个字符串转换为十六进制数据  
  416. // 参数：      s   -   输入字符串  
  417. // 返回值：     字符串代表的十六进制数据  
  418. //=============================================================  
  419. int _str2hex_(char *s)  
  420. {  
  421.     int Ret = 0;  
  422.     s = _strupr_(s);  
  423.     if((s[0] != ‘0‘) || (s[1] != ‘X‘))  
  424.         return 0;  
  425.     s += 2;  
  426.     while(*s)  
  427.     {  
  428.         Ret <<= 4;  
  429.         if((*s >= ‘0‘) && (*s <= ‘9‘))  
  430.             Ret += ((int)*s - ‘0‘);  
  431.         else if((*s >= ‘A‘) && (*s <= ‘Z‘))  
  432.             Ret += ((int)*s - ‘A‘ + 0x0a);  
  433.         else  
  434.             return 0;  
  435.         s++;  
  436.     }  
  437.     return Ret;  
  438. }  
  439.   
  440. //=============================================================  
  441. // 语法格式：    int _str2dec_(char *s)  
  442. // 实现功能：    将一个字符串转换为十进制数据  
  443. // 参数：      s   -   输入字符串  
  444. // 返回值：     字符串代表的十进制数据  
  445. //=============================================================  
  446. int _str2dec_(char *s)  
  447. {  
  448.     int Ret, Flag = 0;  
  449.     Ret = 0;  
  450.     if(*s == ‘-‘)  
  451.     {  
  452.         Flag = 1;  
  453.         s++;  
  454.     }  
  455.     while(*s)  
  456.     {  
  457.         if((*s < ‘0‘) || (*s > ‘9‘))  
  458.             return 0;  
  459.         Ret = Ret * 10 + (int)(*s - ‘0‘);  
  460.         s++;  
  461.     }  
  462.     if(Flag)  
  463.         Ret *= -1;  
  464.     return Ret;  
  465. }  

C 语言字符串处理函数实现合集

原文：http://blog.csdn.net/nyist327/article/details/46538063
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！