纯C 字符串操作函数实现 (strcpy, strncpy, memcpy, memset, strcat, strlen ... )

最新推荐文章于 2022-08-10 17:56:31 发布

sengeiou

最新推荐文章于 2022-08-10 17:56:31 发布

阅读量3k

点赞数 2

分类专栏：面试文章标签：纯C 字符串操作函数实现 strcpy strncpy memcpy memset strcat

面试专栏收录该内容

28 篇文章 1 订阅

订阅专栏

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

strcpy:

[cpp]view plaincopyprint? 
   
 char* cb_strcpy(char* dst, const char* src) {  
        
      assert((dst!=NULL) && (src!=NULL));  
        
      char* retAddr = dst;       /**< retAddr is in static , char retAddr[] will in Stack, So... */  
      while ((*(dst++) = *(src++))!='\0') {   
           ;  
      }  
        
      return retAddr;  
 }  

strncpy:

[cpp]view plaincopyprint? 
   
 char* cb_strncpy(char* dst, const char* src, size_t size) {  
        
      assert((dst!=NULL) && (src!=NULL));  
        
      char* retAddr = dst;       /**< retAddr is in static , char retAddr[] will in Stack, So... */  
      int i = 0;   
      while (((*(dst++) = *(src++))!='\0') && ((i++) < size)) {   
           ;  
      }  
        
      *(retAddr+size)='\0';      /**< cut off String  */  
        
      return retAddr;  
 }  

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

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

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

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

memcpy Version 1:

[cpp]view plaincopyprint? 
   
 char* cb_memcpyVer1(char* dst, const char* src, size_t size) {  
        
      assert((dst!=NULL) && (src!=NULL));  
   
      char* retAddr = dst;  
      while (size-- > 0) {           
           *(dst++) = *(src++);  
      }  
      return retAddr;  
 }  

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

memcpy Version 2 :

[cpp]view plaincopyprint? 
   
 char* cb_memcpyVer2(char* dst, const char* src, size_t size) {  
        
      assert((dst!=NULL) && (src!=NULL));  
        
      char* retAddr = dst;  
      size_t i = 0;  
      /* --- 解决数据区重叠问题 --- */  
      if ((retAddr>src) && (retAddr<(src+size))) {  
           for (i=size-1; i>=0; i--) {  
                *(dst++) = *(src++);  
           }  
      }  
      else  
      {  
           for (i=0; i<size; i++) {  
                *(dst++) = *(src++);  
           }  
      }  
      *(retAddr+size)='\0';  
        
      return retAddr;  
 }  

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

memcpy还有种蛋疼的写法：

[cpp]view plaincopyprint? 
   
 void* cb_memcpy(void* dest, const void* src, size_t count)  
 {  
     char* d = (char*)dest;  
     const char* s = (const char*)src;  
     /* --- 每次复制8bit --- */  
     int n = (count + 7) / 8;  
     switch(count & 7)  
     {  
     case 0: do {   *d++ = *s++;  
     case 7:        *d++ = *s++;  
     case 6:        *d++ = *s++;  
     case 5:        *d++ = *s++;  
     case 4:        *d++ = *s++;  
     case 3:        *d++ = *s++;  
     case 2:        *d++ = *s++;  
     case 1:        *d++ = *s++;  
                } while (--n > 0);  
     }  
   
     return dest;  
 }  

memset:

[cpp]view plaincopyprint? 
   
 void* cb_memset(void* buffer, int b, size_t size) {  
        
      assert(buffer!=NULL);  
      char* retAddr = (char*)buffer;  
      while (size-- > 0) {  
           *(retAddr++) = (char)b;    
      }  
      return retAddr;  
 }  

Memset使用时误区:

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

strlen:

[cpp]view plaincopyprint? 
   
 int cb_strlen(const char* str) {  
        
      assert(str!=NULL);  
        
      int len = 0;  
      while (*str!='\0') {       /**< '\0', stop */  
           str++;  
           len++ ;  
      }  
        
      return len;  
 }  

Recursive strlen:

[cpp]view plaincopyprint? 
   
 int cb_strlen(const char *str)  
 {  
      if ((str == NULL) || (*str == '\0')) {  
           return 0;  
      }  
      else  
      {  
           return cb_strlen(str+1)+1; /**< Rescursive */  
      }  
 }  

strcat:

[cpp]view plaincopyprint? 
   
 char* cb_strcat(char* dst, char* src) {  
        
      assert(src!=NULL);  
        
      char* retAddr = dst;  
      /* --- Find last position --- */  
      while (*dst++ != '\0') {  
           ;  
      }  
      dst--;  
      while (*dst++ = *src++) {  
           ;  
      }  
      return retAddr;  
 }  

strcmp:

[cpp]view plaincopyprint? 
   
 int cb_strcmp(char* str, char* str2) {  
        
      assert((str!=NULL) && (str2!=NULL));  
        
      char* pStr = str;  
      char* pStr2 = str2;  
      while (*pStr && *pStr2 && (*pStr==*pStr2)) {  
           pStr++;  
           pStr2++;  
      }  
      return (*pStr - *pStr2);   /**< 相等则为0 , 前者大于后者大于0, 反之小于0 */  
 }  

strncmp:

[cpp]view plaincopyprint? 
   
 int cb_strncmp(char* str, char* str2, size_t size) {  
        
      assert((str!=NULL) && (str2!=NULL));  
        
      char* pStr = str;  
      char* pStr2 = str2;  
      while (size-- && *pStr && *pStr2 && (*pStr == *pStr2)) {  
           pStr++;  
           pStr2++;  
      }  
      return (*pStr - *pStr2);     
 }  

strchr:

[cpp]view plaincopyprint? 
   
 char* cb_strchr(char* str, char c){  
        
      assert(str!=NULL);  
      char* retAddr = str;  
        
         while (*retAddr!=c) {  
           retAddr++;  
      }  
      if (*retAddr == c) {  
           return retAddr;  
      }  
      else  
      {  
           return NULL;  
      }  
 }  

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

比如这个程序：

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

这个结果为: cdedefg .

再看下面这个程序：

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

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

最近查看了微软的c标准库针对字符串操作的部分源代码，整理了一下放上来
char * strcat(char * dst, const char * src)
{
 char * cp = dst;
 
 while(*cp)
 {
  cp++;  /* find end of dst */
 }
 
 while (*cp++ = *src++); /* Copy src to end of dst */
 
 return dst; /* return dst */
}

char * strcpy(char * dst, const char * src)
{
 char * cp = dst;
 
 while (*cp++ = *src++);  /* Copy src over dst */
 
 return dst;
}

char * strchr(const char * string, int ch)
{
 while (*string && *string != (char)ch)
 {
  string++;
 }
 
 if (*string  == (char)ch;
  return (char *)string;
 
 return NULL;
}

int strcmp(const char * src, const char * dst)
{
 int ret = 0;
 
 while (!(ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
  ++src, ++dst;
  
 if ( ret < 0 )
   ret = -1 ;
  else if ( ret > 0 )
   ret = 1 ;

  return( ret );
}

size_t strlen(const char * str)
{
 const char * eos = str;
 
 while (*eos++);
 
 return (int)(eos - str - 1);
}

char * strstr(const char * str1, const char * str2)
{
 char * cp = (char *)str1;
 char *s1, *s2;
 
 if (!*str2)
  return (char *)str1;
 
 while (*cp)
 {
  s1 = cp;
  s2 = str2;
  
  while (*s1 && *s2 && !(*s1-*s2))
   s1++, s2++;
  
  while (!*s2)
   return cp;
  
  cp++;
 }
 
 return NULL;
}

如果你的简历上，写了你精通C/C++，如果让你写个字符串函数，结果写不出来，是不是很囧。
字符串是C中很重要的一部分，我们在编程的操作上，很多都是处理字符串的。
对C中的字符串你应该这样认识，它是一个结尾带'\0'的数组。不关写成
char *s = "nihao";
char s[] ="nihao";
char s[10] = "nihao";
他们在内存中都是可以认为是数组形式的存在，连续的存放，最后以'\0'结尾。
数组在Ｃ中是二等公民，所以它不是像内置类型int,double,...等这样可以直接写=,>,==...这样进行操作的。
他需要用到string.h中的字符串处理函数。
首先结束3个最常用的。
1，字符串拷贝函数strcpy(); //string copy;
2，字符串比较函数strcmp(); //string compare;
3，字符串长度函数strlen(); //string length;
下面是上面3个函数的实现
#include <stdio.h>
//字符串拷贝函数，把dest指向的字符串拷贝到source中
char *mystrcpy(char *source,const char *dest)
{
char *s = source;
while (*dest!='\0')
   *s++ = *dest++;
*s = '\0';
return source;
}
//字符串比较函数，相等返回0，s1大返回正整数，s2大返回负整数
int mystrcmp(const char *s1,const char *s2)
{
    while(*s1!='\0'&&*s2!='\0'&&(*s1==*s2))s1++,s2++;
    return (*s1)-(*s2);
}
//字符串长度函数,长度不包括结尾的'\0'
int mystrlen(const char *s)
{
int res = 0;
while(*s++!='\0')
   res++;
return res;
}
void main()
{
char data[100];
char *s = "ni";
char *s1 = "nihao";
mystrcpy(data,s);
printf("%s,%d\n",data,mystrlen(s));
printf("%d\n",mystrcmp(s,s1));
}
注：这3个函数常用，实现的代码其实也简单，可以看到，每个函数的体的代码不超过5行。最少的2行。
其次是会用到的，没有前3个那么高。
1，字符串连接函数strcat();//string catenate
2，字符串转换为小写函数strlwr();//string lowercase
3，字符串转换为大写函数strupr();//string uppercase
字符串连接函数，类似C++中的+号操作。大小写字母的转换，本质上就是ASCII码值加减32.
下面是这3个函数的实现。
#include <stdio.h>
//字符串连接函数
char *mystrcat(char *source,const char *dest)
{
char *s = source;
while(*s!='\0')s++;
while(*dest!='\0')*s++ = *dest++;
*s='\0';
return source;
}
//字符串转换小写字母函数
char *mystrlwr(char *source)
{
   char *s = source;
   do 
   {
   if(*s>='A'&&*s<='Z')
      *s+=32;
   } while (*s++!='\0');
   return source;
}
//字符串转换大写字母函数
char *mystrupr(char *source)
{
char *s = source;
do 
{
   if(*s>='a'&&*s<='z')
    *s-=32;
} while (*s++!='\0');
    return source;
}
void main()
{
char data[100]="ni";
char *s = " hao!";
printf("%s\n",mystrcat(data,s));
printf("%s\n",mystrupr(data));
printf("%s\n",mystrlwr(data));
}
注：看这3个函数的代码实现也不难，函数体内的代码也不长。大小写转换函数很相似。
然后说几个不常用，但往往确会容易面试遇到的字符串处理函数。
1，字符串倒转函数。strrev();//string reverse
2，字符串查找字符串第一次出现函数。strstr();
这2个函数实现如下：
#include <stdio.h>
//字符串倒转函数
char *mystrrev(char *source)
{
char *s1 = source,*s2 = source,temp;
while(*s2!='\0')s2++;
if(s1!=s2)s2--;
while(s1<s2)temp = *s1,*s1 = *s2,*s2 = temp,s1++,s2--;
return source;
}
//字符串查找指定字符串的第一次出现,没有出现返回NULL，出现则返回出现的位置
char *mystrstr(const char *source,const char *dest)
{
   char *s = source,*d = dest;
   while(*source!='\0')
   {
    while(*s!='\0'&&*d!='\0'&&*s==*d)s++,d++;
    if(*d=='\0')
    {
     s = source;break;
    }
    if(*s=='\0')
    {
     s = NULL;break;
    }
       source++;
    s=source,d=dest;
   }
   if (*source=='\0')s=NULL;
   return s;
}
void main()
{
char data[100]="huifeng00 : ni hao";
char *s = " in";
printf("%s\n",mystrrev(data));
printf("%s\n",mystrstr(data,s));
}
最后说一个调用比较另类的字符串处理函数
1，查找由第2个字符串指定分界符对第一个串分解后的单词函数
strtok();//string token;
函数原型：char *strtok(char *s, const char *delim);它的调用比较特别。
首次调用s指向要分解的串，以后在调用s参数则设为NULL。
例如：char data[] = "a,b,c,d";
分界符","就是逗点，字符串形式表示。
第一次调用strtok(data,",");然后在调用就是strtok(NULL,",");
这个函数的处理思想：用一个静态变量记录每次调用时候分解字符串的处理指针位置，且每次调用的时候，
把字符串中出现分界符的字符用'\0'替换，直到把字符串遍历完为止。
这个函数的实现
#include <stdio.h>
#include <string.h>
char * mystrtok(char * source, char *delim)
{
static char *begin;
if (source!=NULL)
{
   begin = strstr(source,delim);
   while(begin==source)
   {
    source += strlen(delim);
    begin = strstr(source,delim);
   }
}
else
{
        source = begin;
   if (source==NULL)
   {
    return NULL;
   }
   begin = strstr(source,delim);
   while(begin==source)
   {
    source += strlen(delim);
    begin = strstr(source,delim);
   }
}
if (begin!=NULL)
{
   memset(begin,0,strlen(delim));
   begin += strlen(delim);
}
else
   if (*source==0)
   {
    return NULL;
   }
   return source;
}
void main()
{
char data[100]=" huifeng00 ni hao";
char *p = mystrtok(data," ");
printf("%s\n",p);
while (p!=NULL)
{
   p = mystrtok(NULL," ");
   if(p!=NULL)
        printf("%s\n",p);
}
}
以前专门写过这个函数的实现
http://hi.baidu.com/huifeng00/blog/item/f8dfa80b420a408ed0581b0f.html
能看到这里，算你有耐心。
算是一个总结吧。用了一定的时间写代码和文章。
希望对能看到这篇文章的C爱好者有帮助。
coder:huifeng00