C语言字符串库函数的实现

简介:

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

复制代码
//字符串长度
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;       
}
//strncpy(),如果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个字节设置成字符c
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);  
} 
复制代码
    本文转自阿凡卢博客园博客,原文链接: http://www.cnblogs.com/luxiaoxun/archive/2012/09/04/2670202.html ,如需转载请自行联系原作者
相关文章
|
15天前
|
C语言 C++
C语言 之 内存函数
C语言 之 内存函数
30 3
|
6天前
|
存储 缓存 C语言
【c语言】简单的算术操作符、输入输出函数
本文介绍了C语言中的算术操作符、赋值操作符、单目操作符以及输入输出函数 `printf` 和 `scanf` 的基本用法。算术操作符包括加、减、乘、除和求余,其中除法和求余运算有特殊规则。赋值操作符用于给变量赋值,并支持复合赋值。单目操作符包括自增自减、正负号和强制类型转换。输入输出函数 `printf` 和 `scanf` 用于格式化输入和输出,支持多种占位符和格式控制。通过示例代码详细解释了这些操作符和函数的使用方法。
24 10
|
5天前
|
机器学习/深度学习 C语言
【c语言】一篇文章搞懂函数递归
本文详细介绍了函数递归的概念、思想及其限制条件,并通过求阶乘、打印整数每一位和求斐波那契数等实例,展示了递归的应用。递归的核心在于将大问题分解为小问题,但需注意递归可能导致效率低下和栈溢出的问题。文章最后总结了递归的优缺点,提醒读者在实际编程中合理使用递归。
29 7
|
5天前
|
存储 编译器 程序员
【c语言】函数
本文介绍了C语言中函数的基本概念,包括库函数和自定义函数的定义、使用及示例。库函数如`printf`和`scanf`,通过包含相应的头文件即可使用。自定义函数需指定返回类型、函数名、形式参数等。文中还探讨了函数的调用、形参与实参的区别、return语句的用法、函数嵌套调用、链式访问以及static关键字对变量和函数的影响,强调了static如何改变变量的生命周期和作用域,以及函数的可见性。
19 4
|
10天前
|
存储 编译器 C语言
C语言函数的定义与函数的声明的区别
C语言中,函数的定义包含函数的实现,即具体执行的代码块;而函数的声明仅描述函数的名称、返回类型和参数列表,用于告知编译器函数的存在,但不包含实现细节。声明通常放在头文件中,定义则在源文件中。
ly~
|
15天前
|
数据可视化 BI API
除了 OpenGL,还有哪些常用的图形库可以在 C 语言中使用?
除了OpenGL,C语言中还有多个常用的图形库:SDL,适合初学者,用于2D游戏和多媒体应用;Allegro,高性能,支持2D/3D图形,广泛应用于游戏开发;Cairo,矢量图形库,支持高质量图形输出,适用于数据可视化;SFML,提供简单接口,用于2D/3D游戏及多媒体应用;GTK+,开源窗口工具包,用于创建图形用户界面。这些库各有特色,适用于不同的开发需求。
ly~
30 4
|
16天前
|
C语言
c语言回顾-函数递归(上)
c语言回顾-函数递归(上)
29 2
|
18天前
|
Java 编译器 C语言
【一步一步了解Java系列】:Java中的方法对标C语言中的函数
【一步一步了解Java系列】:Java中的方法对标C语言中的函数
18 3
|
21天前
|
存储 程序员 编译器
C语言——动态内存管理与内存操作函数
C语言——动态内存管理与内存操作函数
|
21天前
|
C语言
C语言字符(串)函数
C语言字符(串)函数