字符串中常见函数的实现_legend



字符串操作函数的自我实现：
（1）strcpy(),strncpy()的实现：
（2）strcat(),strncat()的实现：
（3）strstr()的实现：
（4）memcpy()的实现：
（5）memset()的实现：
（6）strcmp()的实现,strncmp()的实现：
（7）strstr()的实现：
（8）strlen()的实现：
-------------------------------
（1）strcpy()的实现：
函数原型是 char *strcpy(char *strDest,const char *strSrc)；，其中strDest是目的字符串，strSrc是源字符串。

实现：
char *strcpy(char *strDest,const char *strSrc)
{
    assert((strDest!=NULL)&&(strSrc!=NULL));
 //assert()中的条件为真时，继续执行，否则退出。

    char *address=strDest;
    while((*strDest++=*strSrc++)!='\0');
 //不需要在末尾添加*strDest='\0',因为结束时，已经='\0';
    return address;
}

/*注意：
1.strncpy中对于dest末尾的'\0'的处理
2.&&的运算顺序问题
*/
char* strncpy(char* dest,const char* src, int count){
 assert(dest!=NULL && src!=NULL);
 char* temp=dest;
 int i=0;

 while(i++< count && (*dest++=*src++)!='\0');

 //注意对于temp的末尾的'\0'的处理
 *temp='\0';

 return temp;
}

注意：刚开始我写strncpy的实现时，把while(i++ < len && (*temp++ = *src++)!='\0')写成了while( (*temp++ = *src++)!='\0' && i++ < len); 导致最后多复制了一个字符。  因为&&运算顺序的问题，只要&&的左边为假，则整体为假，右边不再执行。

------

（2）memcpy:内存拷贝函数；
1）说明：
void *memcpy(const void *dest, const void *src, size_t n);
从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。

2）说明：
1.注意目的地址和源地址重合的问题，拷贝前要加以判断。
2.一般要把原来的指针类型转换成char*，这样每次移动都是一个字节。
3.memcpy是一次复制一个字节，不一定是字符串，所以不需要在结尾加上'\0';
3）实现：

void * memcpy(const void * dest,  const void * src, int len){
 
 int i=0;
 const char* tempdest=(char*)dest;
 const char* tempsrc=(char*) src;

 assert(tempdest!=NULL && tempsrc!=NULL);

 //tempdest在tempsrc到tempsrc+len-1之间，
 //如果从头到尾赋值，则*tempsrc赋值给*tempdest，会发生覆盖，
 //所以从后往前开始赋值。

 if(tempdest>=tempsrc && tempdest<=(tempsrc+len-1) ){
  tempdest+=len;
  tempsrc+=len;
  i=len;

  while(i>0){
   *tempdest-- = *tempsrc--;
   i--;
  }

 }else{
  while(i<len){
   *tempdest++ = *tempsrc++;
   i++;
  }
  
 }

 return dest;
}
  
  

3）memcpy与strcpy的区别：

1、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。
2、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符"\0"才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。
3、用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy

------

（3）strcat();

 char * strcat(char * dest ,const char* src){
  char * tmp=dest;
  while(*dest)//定位到dest的'\0'位置处，从这个位置开始追加。
  dest++;

  while((*dest++=*src++)!='\0');

  return tmp;
 }

/*
注意：1.strncat结尾处'\0'的处理；
2.&&的运算顺序问题；
*/

 char * strncat(char * dest ,const char* src, int n){
   char *tmp=dest;//保存dest的初始值

   assert(dest!=NULL && src!=NULL);

   while(*dest !='\0')
   dest++;

   while(n-- && (*dest++ = *src++ )!='\0' );

   
   *dest='\0';

   return tmp;
   
 }

注意：如果将n-- && (*dest++ = *src++ )!='\0'写为
(*dest++ = *src++ )!='\0' && n--,则会多复制一个元素。

 -------

 （3）memset的实现：
 1）函数头：
 void * memset(void * dest ,int c ,int len);
 2）功能：
 将dest所指地址开始的len个字节的内容全部置位为ch所指的ASCII的值。
 3）实现：

 void memset(void * dest ,int c ,int len){
  char * temp=(char *)dest;

  assert(temp!=NULL);

  while(len-->0){
   *temp**=(char) c;
  }

  return dest;
 }

 -------
（6）strcmp()的实现：

/*如果dest > source,则返回值大于0，如果dest = source,则返回值等于0，如果dest  < source ,则返回值小于0。*/ 
 
int strcmp(const char* dest ,const char * src){
 
 int ret=0;

 while( (ret=*(unsigned char *)dest -*(unsigned char *)src )==0  && *dest ){
  dest++;
  src++;
 }

 if(ret<0) return -1;
 else if(ret>0) return 1;
 return 0;
}

 

注意：&&的运算顺序，此中ret=*dest-*src 在 *dest前面。

-------
（6-1）strncmp()的实现:

1）原型：
int strncmp(const char* s1,const char* s2, int n);

2）功能：
比较s1的前n个字符和s2的前n个字符；

3）实现：

int strncmp(const char* s1, const char * s2,int n){
 assert(NULL != s1 && NULL !=s2);

 while(n--){

  if(*s1 && *s1==*s2){
   s1++;
   s2++;
  }
  else {
   return *s1-*s2;
  }
 }

 return 0;//如果前n个字符都相等
}

-------
（7）strstr()的实现：
1）原型：
char * strstr(const char* s1,const char* s2);

2）功能：
在s1中找到s2第一次出现的位置，返回该位置，如果没找到，则返回NULL.

3）实现：

/*

基本思想就是：

对于字符串s1,从左到右，不断的选择选择新的字符作为起点，看s2是否和新起点开始的的字符串的前n个字符相同；

n为s2字符串的长度；

*/

char * strstr(const char* s1, const char* s2){
 int len2;

 if( ( len2=strlen(s2) )==0 )
 return (char*)s1;

 for(;*s1;s1++){
  if(*s1==*s2  && strncmp(s1,s2,len2)==0 )
  return (char*) s1;
 }

 return NULL;
}

方法二：

const char* Strstr(const char * str1, const char * str2) {
    assert(str1);
    assert(str2);
    char* cp = (char*)str1;
    char* substr = (char*)str2;
    char* s1 = NULL;
    if (*str1 == '\0')
        return NULL;
    while (*cp) {
        s1 = cp;
        substr = str2;
        while (*s1 && *substr && (*s1 == *substr)) {
            s1++;
            substr++;
        }
        if (*substr == '\0')
            return cp;
        cp++;
    }
}
 

----------------
（8）strlen()的实现：

1）原型：
int strlen(const char* str);

2）实现：
方法一：

int strlen(const char * str){
 assert(str!=NULL);

 int len=0;

 while((*str++)!='\0')
 len++;

 return len;
}

方法二：
int strlen(const char* str){
 assert(str);

 const char* temp=str;

 while(*temp ++);//循环结束*temp=='\0'

 return temp-str-1;
}