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

C 语言字符串处理函数实现合集的相关文章

转：C语言字符串操作函数 - strcpy、strcmp、strcat、反转、回文

转自:C语言字符串操作函数 - strcpy.strcmp.strcat.反转.回文 作者:jcsu C语言字符串操作函数 1. 字符串反转 - strRev2. 字符串复制 - strcpy3. 字符串转化为整数 - atoi4. 字符串求长 - strlen5. 字符串连接 - strcat6. 字符串比较 - strcmp7. 计算字符串中的元音字符个数8. 判断一个字符串是否是回文1. 写一个函数实现字符串反转 版本1 - while版 void strRev(char *s){    

C语言字符串处理函数

函数名: strcpy 功  能: 拷贝一个字符串到另一个 用  法: char *stpcpy(char *destin, char *source); 程序例: #include <stdio.h> #include <string.h> int main(void) {    char string[10];    char *str1 = "abcdefghi";    stpcpy(string, str1);    printf("%sn&

Strsafe.h：更安全的C语言字符串处理函数

原文出处:Strsafe.h: Safer String Handling in C 作者:Michael Howard 编译:王凌峰 在微软公司举行的Microsoft Windows Security Push 活动期间,一批测试者.程序管理经理和普通程序员共同决定要为 C 语言量身定制一套具有较高安全性的字符串处理函数,并且希望这些函数能被 Windows 程序员和微软公司内部的程序员所采用. 简单说来,现有的 C 语言运行时函数实在难以在当今充斥着恶意攻击企图的大环境下立足.这些函数要么

【前端】Util.js-ES6实现的常用100多个javaScript简短函数封装合集（持续更新中）

Util.js (持续更新中...) 项目地址: https://github.com/dragonir/Util.js 项目描述 Util.js 是对常用函数的封装,方便在实际项目中使用,主要内容包含:数组类.浏览器类.日期类.函数类.数学类.媒体类.节点类.对象类.字符串类.类型检测类.正则表达式类等内容. 使用方法 1. 引入Bable transpiler以保证支持ES6 <script type="javascript/text" src="./browser

基本字符串相关函数，基本宏，内存相关函数，类型转换函数实现合集

1．常用宏或函数的实现_T,_L宏:#define unsigned short L#define _T(x)       __T(x)#define _TEXT(x)    __T(x) #ifdef  _UNICODE#define __T(x) L##x     #else#define __T(x) x          #endif #define _L(x) L##x assert宏实现:#define assert(expr)do{    if (!(expr))    {    

c语言字符串分割函数（strtok()）

头文件:#include <string.h> 定义函数:char * strtok(char *s, const char *delim); 函数说明:strtok()用来将字符串分割成一个个片段.参数s 指向欲分割的字符串,参数delim 则为分割字符串,当strtok()在参数s 的字符串中发现到参数delim 的分割字符时则会将该字符改为\0 字符.在第一次调用时,strtok()必需给予参数s 字符串,往后的调用则将参数s 设置成NULL.每次调用成功则返回下一个分割后的字符串指针.

C语言字符串操作函数整理

#include<stdio.h> #include<string.h> #include<stdlib.h> int main() {     char *str1="hello world!";     char *str2="HELLO WORLD!";     int len=strlen(str1);//求的字符串长度,不包括'\0'在内     printf("len=%d\n",len);    

C语言-字符串操作函数

gets(char buffer[]) 从标准输入读取一行, 并去掉换行符, 在字符串末尾增加 '\0' 字符, 写入到缓冲区 成功则返回 buffer 的地址, 出错或者遇到文件结尾则返回空指针, 使用 stdio 的  NULL 表示 fgets(char buffer[], int num, FILE * f) 从指定文件 f 中读取 num - 1 个字符, 去掉换行符, 并在末尾添加 '\0' 字符, 写入到 buffer scanf(const char * format [, ar

C语言字符串操作函数

来源:http://www.cnblogs.com/JCSU/articles/1305401.html 1. 字符串反转 - strRev2. 字符串复制 - strcpy3. 字符串转化为整数 - atoi4. 字符串求长 - strlen 5. 字符串连接 - strcat6. 字符串比较 - strcmp 7. 计算字符串中的元音字符个数 8. 判断一个字符串是否是回文 1. 写一个函数实现字符串反转 版本1 - while版 void strRev(char *s) {     cha