码迷，mamicode.com
首页 > 编程语言 > 详细

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

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

标签：c   字符串处理函数   库函数   面试   练习   

其中包括：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 语言字符串处理函数实现合集

标签：c   字符串处理函数   库函数   面试   练习   

原文地址：http://blog.csdn.net/nyist327/article/details/46538063
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！