【转】字符串操作函数 C语言实现 (strcpy, strncpy, memcpy, memset, strcat, strlen ... )

实现C/C++中的字符串操作函数是很练内功的,别看着这些函数很简单,自己实现起来,还是有许多地方需要考虑的,所以没独立写过的朋友,可以自己敲敲看 . --By Crazybaby

strcpy:

  1. char* cb_strcpy(char* dst, const char* src) {  
  2.        
  3.      assert((dst!=NULL) && (src!=NULL));  
  4.        
  5.      char* retAddr = dst;       /**< retAddr is in static , char retAddr[] will in Stack, So... */  
  6.      while ((*(dst++) = *(src++))!='\0') {   
  7.           ;  
  8.      }  
  9.        
  10.      return retAddr;  
  11. }  

 

strncpy:

  1. char* cb_strncpy(char* dst, const char* src, size_t size) {  
  2.        
  3.      assert((dst!=NULL) && (src!=NULL));  
  4.        
  5.      char* retAddr = dst;       /**< retAddr is in static , char retAddr[] will in Stack, So... */  
  6.      int i = 0;   
  7.      while (((*(dst++) = *(src++))!='\0') && ((i++) < size)) {   
  8.           ;  
  9.      }  
  10.        
  11.      *(retAddr+size)='\0';      /**< cut off String  */  
  12.        
  13.      return retAddr;  
  14. }  

这个strncpy实现版本 和 stdlib.h 下的 strncpy 还是有区别的, 比如 

  1. char a[30];  
  2. strncpy(a, "Hello", 28);  //a除了有Hello,之后会有23个repeat '\0' . 这样会有效率的问题.   
  3.   
  4. char b[30];  
  5. cb_strncpy(b, "Hello", 28);   // 而只有 Hello'\0'   

 

CB:  strncpy相对于strcpy来说 ,安全性提高了一个等级 . 另外一个要非常注意的地方那个是 strcpy 和 strncpy 都会遇到 '\0' 结束.  

          另外:当请求的目标地址空间比源字符串空间要小的时候,strncpy 将不再用”\0”来结束字符串。这是一个巨大的隐患,所以还是不安全

 

memcpy Version 1:

  1. char* cb_memcpyVer1(char* dst, const char* src, size_t size) {  
  2.        
  3.      assert((dst!=NULL) && (src!=NULL));  
  4.   
  5.      char* retAddr = dst;  
  6.      while (size-- > 0) {           
  7.           *(dst++) = *(src++);  
  8.      }  
  9.      return retAddr;  
  10. }  

 

CB: memcpy 和 strncpy 最大的区别是 memcpy不会遇到 '\0' 结束拷贝 .

 

memcpy Version 2 :

  1. char* cb_memcpyVer2(char* dst, const char* src, size_t size) {  
  2.        
  3.      assert((dst!=NULL) && (src!=NULL));  
  4.        
  5.      char* retAddr = dst;  
  6.      size_t i = 0;  
  7.      /* --- 解决数据区重叠问题 --- */  
  8.      if ((retAddr>src) && (retAddr<(src+size))) {  
  9.           for (i=size-1; i>=0; i--) {  
  10.                *(dst++) = *(src++);  
  11.           }  
  12.      }  
  13.      else  
  14.      {  
  15.           for (i=0; i<size; i++) {  
  16.                *(dst++) = *(src++);  
  17.           }  
  18.      }  
  19.      *(retAddr+size)='\0';  
  20.        
  21.      return retAddr;  
  22. }  

 

CB: memcpyVersion1不能防止overlapping区域的问题, Ver2很好的解决了.

       

memcpy还有种蛋疼的写法:

 

  1. void* cb_memcpy(void* dest, const void* src, size_t count)  
  2. {  
  3.     char* d = (char*)dest;  
  4.     const char* s = (const char*)src;  
  5.     /* --- 每次复制8bit --- */  
  6.     int n = (count + 7) / 8;  
  7.     switch(count & 7)  
  8.     {  
  9.     case 0: do {   *d++ = *s++;  
  10.     case 7:        *d++ = *s++;  
  11.     case 6:        *d++ = *s++;  
  12.     case 5:        *d++ = *s++;  
  13.     case 4:        *d++ = *s++;  
  14.     case 3:        *d++ = *s++;  
  15.     case 2:        *d++ = *s++;  
  16.     case 1:        *d++ = *s++;  
  17.                } while (--n > 0);  
  18.     }  
  19.   
  20.     return dest;  
  21. }  



 

memset:

  1. void* cb_memset(void* buffer, int b, size_t size) {  
  2.        
  3.      assert(buffer!=NULL);  
  4.      char* retAddr = (char*)buffer;  
  5.      while (size-- > 0) {  
  6.           *(retAddr++) = (char)b;    
  7.      }  
  8.      return retAddr;  
  9. }  

 

Memset使用时误区: 

 

  1. char a[10];  
  2. memset(a, 0, sizeof(char)*10); //这个操作完全没必要 因为下面这块内存马上要被使用了。  
  3. memcpy(a, "Hello", 5);  



 

 

strlen:

  1. int cb_strlen(const char* str) {  
  2.        
  3.      assert(str!=NULL);  
  4.        
  5.      int len = 0;  
  6.      while (*str!='\0') {       /**< '\0', stop */  
  7.           str++;  
  8.           len++ ;  
  9.      }  
  10.        
  11.      return len;  
  12. }  

 

Recursive strlen:

  1. int cb_strlen(const char *str)  
  2. {  
  3.      if ((str == NULL) || (*str == '\0')) {  
  4.           return 0;  
  5.      }  
  6.      else  
  7.      {  
  8.           return cb_strlen(str+1)+1; /**< Rescursive */  
  9.      }  
  10. }  



strcat:

  1. char* cb_strcat(char* dst, char* src) {  
  2.        
  3.      assert(src!=NULL);  
  4.        
  5.      char* retAddr = dst;  
  6.      /* --- Find last position --- */  
  7.      while (*dst++ != '\0') {  
  8.           ;  
  9.      }  
  10.      dst--;  
  11.      while (*dst++ = *src++) {  
  12.           ;  
  13.      }  
  14.      return retAddr;  
  15. }  



strcmp:

  1. int cb_strcmp(char* str, char* str2) {  
  2.        
  3.      assert((str!=NULL) && (str2!=NULL));  
  4.        
  5.      char* pStr = str;  
  6.      char* pStr2 = str2;  
  7.      while (*pStr && *pStr2 && (*pStr==*pStr2)) {  
  8.           pStr++;  
  9.           pStr2++;  
  10.      }  
  11.      return (*pStr - *pStr2);   /**< 相等则为0 , 前者大于后者大于0, 反之小于0 */  
  12. }  



strncmp:

  1. int cb_strncmp(char* str, char* str2, size_t size) {  
  2.        
  3.      assert((str!=NULL) && (str2!=NULL));  
  4.        
  5.      char* pStr = str;  
  6.      char* pStr2 = str2;  
  7.      while (size-- && *pStr && *pStr2 && (*pStr == *pStr2)) {  
  8.           pStr++;  
  9.           pStr2++;  
  10.      }  
  11.      return (*pStr - *pStr2);     
  12. }  



strchr:

  1. char* cb_strchr(char* str, char c){  
  2.        
  3.      assert(str!=NULL);  
  4.      char* retAddr = str;  
  5.        
  6.         while (*retAddr!=c) {  
  7.           retAddr++;  
  8.      }  
  9.      if (*retAddr == c) {  
  10.           return retAddr;  
  11.      }  
  12.      else  
  13.      {  
  14.           return NULL;  
  15.      }  
  16. }  

 

这些字符串操作函数实现时要注意这些问题 :
1. 需要检查指针的有效性,一般通过直接和NULL进行比较来判断。
2. 函数需要能够进行链式操作,也就是说 char* a = strcpy(b, "Hello"); 
3. src的值需要加 const
4. strcnpy 和 memcpy  有 '\0' 判断的区别 
5. 内存区重叠问题 :

 比如这个程序:

 

  1. int main(void) {  
  2.      char buffer[]="abcdefg";  
  3.      memcpy(buffer, buffer+2 ,3); //buffer+2(从c开始 长度3个 cde)   
  4.      printf("%s", buffer);  
  5. }  


这个结果为: cdedefg .

 

再看下面这个程序:

 

  1. int main(void) {  
  2.      char buffer[]="abcdefg";  
  3.      memcpy(buffer+2, buffer ,3); //如果你幸运的话 会出现 abcab[d]fg 中括号是随机值  
  4.      printf("%s", buffer);  
  5. }  

这里的memcpy就需要用 memmove的实现方式来代替 。

 

转自:http://blog.csdn.net/crazyjixiang/article/details/6720236

posted @ 2013-04-18 16:16  c_cloud  阅读(861)  评论(0编辑  收藏  举报