C语言字符串库函数的实现也是笔试题常考的题目，以下代码没有严格测试，只是简单的实现：...

最新推荐文章于 2024-10-10 10:58:41 发布

weixin_34054866

最新推荐文章于 2024-10-10 10:58:41 发布

阅读量141

点赞数

文章标签： c/c++ 操作系统

原文链接：http://blog.51cto.com/10622551/1686199

版权

C语言字符串库函数的实现也是笔试题常考的题目，以下代码没有严格测试，只是简单的实现：

1.int strlen(const char *str) //求字符串的长度

2.char *strcpy(char *to, const char *from)//字符串复制函数

3.void * memset(void* buffer, int c, size_t count)//把指定内存区域的前count个字节设置c成字符

4.char *strncpy(char *to, const char *from, size_t count)//如果from指向的字符个数少于count，则用'\0'补齐
5.char *strchr(char *str, int c) //查找字符串s中首次出现字符c的位置
6.char *strcat(char *strDes, const char *strSrc) //字符串连接
7.char *strncat(char *strDes, const char *strSrc, unsigned int count)
8.char *strstr(const char *strSrc, const char *str)//求子串
9.char *strdup_(char *strSrc)将字符串拷贝到新的位置
10.void* memcpy(void* to, const void* from, size_t count)//不支持内存重叠

11.void* memmove(void* to, const void* from, size_t count)//拷贝重叠或者是不重叠的内存块
12.int strcmp(const char *s, const char *t)//字符串比较
13.int stricmp(const char *dst, const char *src)字符串比较（不区分大小写比较，大写字母会被映射为小写字母）

14.

int strncmp(const char *s, const char *t, unsigned int count)//全count个节




部分源码

16.char * __cdecl strcat (char * dst,const char * src)

18.size_t __cdecl strlen (const char * str)

19.char * __cdecl strncpy (char * dest,const char * source,size_t count)

//求字符串的长度

int strlen(const char *str)   
{   
    assert(str != NULL);   
    int len = 0;   
    while (*str ++ != '\0')   
        ++ len;   
    return len;   
}



//字符串复制函数
char *strcpy(char *to, const char *from)
{
    assert((to != NULL) && (from != NULL)); 
    char * result = to;
    while( (*to++ = *from++) != '\0')
        NULL;    
        return result;       
}




//如果from指向的字符个数少于count，则用'\0'补齐char *strncpy(char *to, const char *from, size_t count)
{
    assert((to != NULL) && (from != NULL)); 
       char * result = to;   
        while(count--)
    {       
     if(*from != '\0')
        {  
           *to++ = *from++;
        }    
     else
        {    
           *to++ = '\0';
        }
    }    return result;       
}




//memset():把指定内存区域的前count个字节设置成字符void * memset(void* buffer, int c, size_t count)
{
    assert(buffer != NULL);  
    char * p = (char *)buffer;  
    while(count--)   
    *p++ = (char)c;   
     return buffer;
}





//查找字符串s中首次出现字符c的位置
 char *strchr(char *str, int c)   
{   
    assert(str != NULL);   
    for (; *str != (char)c; ++ str)   
    if (*str == '\0')   
    {
    return NULL; 
    }  
    return str;   
}




 //字符串连接
char *strcat(char *strDes, const char *strSrc)   
{   
    assert((strDes != NULL) && (strSrc != NULL));   
    char *address = strDes;   
    while (*strDes != '\0')   
        ++ strDes;   
    while ((*strDes ++ = *strSrc ++) != '\0')   
        NULL;   
    return address;   
}





char *strncat(char *strDes, const char *strSrc, unsigned int count)   
{   
    assert((strDes != NULL) && (strSrc != NULL));   
    char *address = strDes;   
    while (*strDes != '\0')   
        ++ strDes;   
    while (count -- && *strSrc != '\0' )   
        *strDes ++ = *strSrc ++;   
    *strDes = '/0';   
    return address;   
}   





//查找字符串第一次出现的位置char *strstr(const char *strSrc, const char *str)   
{   
    assert(strSrc != NULL && str != NULL);   
    const char *s = strSrc;   
    const char *t = str;   
    for (; *strSrc != '\0'; ++ strSrc)   
    {   
        for (s = strSrc, t = str; *t != '\0' && *s == *t; ++s, ++t)   
            NULL;   
        if (*t == '\0')   
            return (char *) strSrc;   
    }   
    return NULL;   
} 




//将字符串拷贝到新的位置 
char *strdup_(char *strSrc)
{     
    if(strSrc!=NULL)     
    {     
        char *start=strSrc;     
        int len=0;     
        while(*strSrc++!='\0')     
            len++;     
          
        char *address=(char *)malloc(len+1);     
        assert(address != NULL);  
          
        while((*address++=*start++)!='\0');      
        return address-(len+1);      
    }     
    return NULL;     
}

内存拷贝函数：

//memcpy()拷贝不重叠的内存块 
void* memcpy(void* to, const void* from, size_t count)
{
   assert((to != NULL) && (from != NULL));
   void * result = to;  
   char * pto = (char *)to; 
   char * pfrom = (char *)from;
   assert(pto < pfrom || pto > pfrom + count -1); 
   while(count--)
    {       *pto++ = *pfrom++;
    }    return result;
}





//memmove(), 拷贝重叠或者是不重叠的内存块 
void* memmove(void* to, const void* from, size_t count)
{
    assert((to != NULL) && (from != NULL));
        void * result = to;   
        char * pto = (char *)to;    
        char * pfrom = (char *)from;    //to与from没有重叠
    if(pto < pfrom || pto > pfrom + count -1)
    {      
     while(count--)
       {           *pto++ = *pfrom++;
       }
    }    //to与from有重叠，从后向前move
    else
    {
       pto = pto + count -1;
       pfrom = pfrom + count -1; 
             while(count--)
       {          *pto-- = *pfrom--;
       }
    }    return result;
}

字符串比较函数：

//字符串比较
int strcmp(const char *s, const char *t)   
{   
    assert(s != NULL && t != NULL);   
    while(*s && *t && *s == *t)   
    {   
        ++ s;   
        ++ t;   
    }    return (*s - *t);   
} 



  



//字符串比较（不区分大小写比较，大写字母会被映射为小写字母）int stricmp(const char *dst, const char *src)
{
    assert(s != NULL && t != NULL); 
    int ch1, ch2;   
     while(*dst && *src)
    {if((ch1 = (int)*dst) >= 'A' && (ch1 <= 'Z'))
            ch1 += 0x20;       
             if((ch2 = (int)*src) >= 'A' && (ch2 <= 'Z'))
            ch2 += 0x20;        
            if(ch1 == ch2)
        {            ++ dst;   
                 ++ src;
        }        
        else
         break;
   }   return(ch1 - ch2);
}





int strncmp(const char *s, const char *t, unsigned int count)   
{   
    assert((s != NULL) && (t != NULL));   
    while (*s && *t && *s == *t && count --)   
    {   
        ++ s;   
        ++ t;   
    }   
    return(*s - *t);   
}

c标准库部分源代码

char * __cdecl 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 */ 
  } 
  
  
  
   
  
int __cdecl 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 __cdecl strlen (const char * str)  
{  
    const char *eos = str;  
      
    while( *eos++ ) ;  
      
    return( (int)(eos - str - 1) );  
}  
  
  
  
  
  
  
  
char * __cdecl strncat (char * front,const char * back,size_t count)  
{  
    char *start = front;  
      
    while (*front++)  
        ;  
    front--;  
      
    while (count--)  
        if (!(*front++ = *back++))  
            return(start);  
          
        *front = '\0';  
        return(start);  
}  
  
  
  
  
int __cdecl strncmp (const char * first,const char * last,size_t count)  
{  
    if (!count)  
        return(0);  
      
    while (--count && *first && *first == *last)  
    {  
        first++;  
        last++;  
    }  
      
    return( *(unsigned char *)first - *(unsigned char *)last );  
}  
  
  
  
  
  
  
/* Copy SRC to DEST.  */ 
 char *  strcpy (char * dest,const char* src)   
{  
    reg_char c;  
    char *__unbounded s = (char *__unbounded) CHECK_BOUNDS_LOW (src);  
    const ptrdiff_t off = CHECK_BOUNDS_LOW (dest) - s - 1;  
    size_t n;  
      
    do  
    {  
        c = *s++;  
        s[off] = c;  
    }  
    while (c != '\0');  
      
    n = s - src;  
    (void) CHECK_BOUNDS_HIGH (src + n);  
    (void) CHECK_BOUNDS_HIGH (dest + n);  
      
    return dest;  
}  



  
char * __cdecl strncpy (char * dest,const char * source,size_t count)  
{  
    char *start = dest;  
      
    while (count && (*dest++ = *source++))    /* copy string */  
        count--;  
      
    if (count)                              /* pad out with zeroes */  
        while (--count)  
            *dest++ = '\0';  
          
        return(start);  
}

转载于:https://blog.51cto.com/10622551/1686199