常用string函数整理及简单实现

最新推荐文章于 2022-07-14 12:50:10 发布
原创 最新推荐文章于 2022-07-14 12:50:10 发布 · 713 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#string #函数 #c语言

本文详细介绍了C语言中常用的字符串处理函数，包括strlen、strcmp、strcat等，并提供了每种函数的具体实现代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

（1）strlen函数

函数原型：size_t strlen(const char *s);

功能：计算给定字符串的（unsigned int型）长度，不包括'\0'在内，如果给定的的字符串没赋初值，它会从字符串首地址一直计算，直到遇到'\0'停止。

代码实现：

#include <stdio.h>

int my_strlen(const char *s)
{
    const char *p = s;

    while(*p != '\0')
    {
        p++;
    }
    return p - s;
}

int main()
{
    char a[20] = "Hello,World";
    int len = my_strlen(a);

    printf("%d\n",len);
    return 0;
}
（ 2 ）strcmp函数

函数原型： int strcmp（const char *s1, const char *s2);

功能：比较两个字符串，设这两个字符串为str1，str2，若str1==str2，则返回零；若str1<str2，则返回负数；若str1>str2，则返回正数。

代码实现：

#include <stdio.h>

int my_strcmp(const char *s1, const char *s2)
{
    int ret = 0;

    if(NULL == s1 || NULL == s2 )
    {
        return;
    }
    while(*s1 && *s2 && (*s1 == *s2))
    {
        s1++;
        s2++;
    }
    ret = *s1 - *s2;
    if(ret > 0)
    {
        return 1;
    }
    if(ret == 0)
    {
        return 0;
    }   
    if(ret < 0)
    {
        return -1;
    }
}

int main()
{
    char a[10] = "Hello";
    char b[10] = "Wrold";
    int date = 0;

    date = my_strcmp(a,b);
    printf("%d\n",date);
    return 0;
}
（3）strcat函数

函数原型： char *strcat(char *dest, const char *src);

功能：把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')，即字符串拼接。

代码实现：

#include <stdio.h>

char *my_strcat(char *dest, const char *src)
{
    char *temp = dest;

    if(NULL == src)
    {
        return dest;
    }
    while(*dest != '\0')
    {
        dest++;
    }
    while((*dest++ = *src++) != '\0')
    {
        ;
    }
    dest = '\0';
    return temp;
}

int main()
{
    char a[20] = {"Hello"};
    char b[10] = {"World"};

    my_strcat(a,b);
    printf("%s\n",a);
    return 0;
}

（4）strncat()函数

函数原型： char *strncat(char *dest, const char *src, size_t n);

功能：字符串拼接，同上！（前n个字符）。

代码实现:

#include <stdio.h>
#include <assert.h>

char *my_strncat(char *dest, const char *src,size_t n)
{
    char *ret = dest;

    assert(NULL != dest && NULL != src);  //前置条件断言：代码执行之前必须具备的特性

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

int main()
{
    char a[20] = {"Hello"};
    char b[20] = {"World"};

    my_strncat(a,b,4);
    printf("%s\n",a);
    return 0;
}

（5）strcpy函数

函数原型： char *strcpy(char *dest, const char *src);

功能：把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间

代码实现：

#include <stdio.h>
#include <assert.h>

char *my_strcpy(char *dest ,const char *src)
{
    char *ret = dest;

    assert(NULL != dest);   //断言宏：前置条件断言：代码执行之前必须具备的特性，在<assert.h>头文件中
    assert(NULL != src);
    while((*dest++ = *src++) != '\0');
    return ret;
    
}

int main()
{
    char a[20] = {0};
    char b[20] = {"Hello,World!"};

    my_strcpy(a,b);
    printf("%s\n",a);
    return 0;
}
(6)strncpy函数

函数原型： char *strncpy(char *dest, const char *src, size_t n);

功能：字符串拷贝操作，同上（前 n 个字符）。

代码实现：

#include <stdio.h>
#include <assert.h>

char *my_strncpy(char *dest, const char *src, size_t n)
{
    char *ret = dest;
    
    assert(NULL != dest && NULL != src) ; //前置条件断言：代码执行之前必须具备的特性
    
    while(n && ((*dest++ = *src++ ) != '\0'))
    {
        n--;
    }
    dest = '\0';
    return ret;
}

int main()
{
    char a[20] = {0};
    char b[20] = {"Hello,World!"};

    my_strncpy(a,b,8);
    printf("%s\n",a);
    return 0;
}
（7）strchr 函数

函数原型：char *strchr (const char * s, int c);

功能：查找字符串s中首次出现字符c的位置，str 为目标字符串  c 为要查找的字符。

代码实现：

#include <stdio.h>

char *my_strchr(const char *s,int c)
{

    if(NULL == s)
    {
        return NULL;
    }
    while('\0' != *s)
    {
        if(*s - c == 0)
        {
            return (char *)s;
        }
        s++;
    }
    return NULL;
}


int main()
{
    char *a = "Hello,World!";
    char *ret;

    ret = my_strchr(a,'e');
    printf("%s\n",ret);
    return 0;
}

（8）strtok函数

函数原型： char *strtok(char *str, const char *delim);

功能：分解字符串为一组字符串。str为要分解的字符，delim为分隔符字符（如果传入字符串，则传入的字符串中每个字符均为分割符）。首次调用时，str指向要分解的字符串，之后再次调用要把str设成NULL。

代码实现：

#include <stdio.h>

char *my_strtok(char *str, const char *delim)
{
    static char *move = NULL;
    char *save_str;
    const char *p = delim;
    int i = 0, len;

    if(NULL != str)
    {
        move = str;
    }
    if('\0'== move)
    {
        save_str = NULL;
    }
    else
    {
        save_str = move;
    }

    while('\0' != *p)
    {
        p++;
    }
    len = p - delim;

    while('\0' != *move)
    {
        for(i = 0;i < len;i++)
        {
            if(delim[i] == *move)
            {
                *move = '\0';
                move++;
                return save_str;
            }
        }
        move++;
    }
    return save_str;
}

int main()
{
    char a[50] = {"ABCD,1234,!@#$,abcd"};

    printf("%s\n",my_strtok(a,","));
    return 0;
}

（9）memcpy函数

函数原型： void *memcpy(void *dest, const void *src, size_t n);

功能：从源src所指的内存地址的起始位置开始拷贝n个字节到目标dest所指的内存地址的起始位置中。

代码实现（1）：

#include <stdio.h>

void *my_memcpy(void *dest,const void *src,size_t n)
{
    char *pd = (char *)dest;
    char *ps = (char *)src;

    while(n--)
    {
        *pd++ = *ps++;
    }
    return dest;
}

int main()
{
    char a[20] = {0};
    char b[20] = "Hello,World!";

    my_memcpy(a,b,8);
    printf("%s\n",a);
    return 0;
}

代码实现（2）： 

#include <stdio.h>

void *my_memcpy(void *dest, const void *src, size_t n)
{
    int num_cpu = n / (sizeof(dest));   //按位宽拷贝
    int num_char = n % (sizeof(dest)); //按字节拷贝
    unsigned long *pd = (unsigned long *)dest;
    const unsigned long *ps = (unsigned long *)src;

    if((NULL == dest) || (NULL == src))
    {
        return NULL;
    }
    while(num_cpu--)
    {
        *pd++ = *ps++;
    }
    while(num_char--)
    {
        *((char *)pd++) = *((char *)ps++);
    }
    return dest;
}

int main()
{
    char a[20] = {0};
    char b[20] = "Hello,World!";

    my_memcpy(a,b,8);
    printf("%s\n",a);
    return 0;
}
注：本系统为32位数;

(10)memmove函数

函数原型：void *memmove(void *dest, const void *src,size_t n);

功能：从src拷贝n个字节到dest，如果目标区域和源区域有重叠的话，memmove能够保证源串在被覆盖之前将重叠区域的字节拷贝到目标区域中。但复制后src内容会被更改，但是当目标区域与源区域没有重叠则和memcpy函数功能相同。

代码实现：

#include <stdio.h>

void *my_memmove(void *dest, const void *src,size_t n)
{
    char *pd,*ps;

    if((NULL == dest) || (NULL == src))
    {
        return NULL;
    }
    if((char *)dest > (char *)src &&(char *)dest < (char *)src + n )
    {
        pd = (char *)dest + n - 1;
        ps = (char *)src + n - 1;
        while(n--)
        {
            *pd-- = *ps--;
        }
    }
    else
    {
        pd = (char *)dest;
        ps = (char *)src;
        while(n--)
        {
            *pd++ = *ps++;
        }
    }
    return dest;
}

int main()
{
    char a[20] = {0};
    char b[20] = {"Hello,World!"};
    
    my_memmove(a,b,8);
    printf("%s\n",a);
    return 0;
}

注：相比上个memcpy函数，该函数考虑了内存重叠的情况，概括的讲，内存重叠分为两种情况；

（1）如果是前面的内存要复制到后面的内存，那么每次移动的时候应该倒序复制字节。

（2）如果是后面的内存复制到前面的内存，那么每次移动的时候应该正序复制字节。

（11）memset函数

函数原型： void *memset(void *s, int c, size_t n);

功能：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种常用方法

注：按字节填充

代码实现：

#include <stdio.h>

void *my_memset(void *s,int c,size_t n)
{
    char *ps = (char *)s;
    
    if((NULL == s) || c < 0)
    {
        return NULL;
    }
    while(n--)
    {
        *ps++ = c;
    }
    return s;
}

int main()
{
    char a[10] = {1,2,3,4,5,6,7,8,9,10};
    int i;

    for(i = 0;i < 10;i++)
    {
        printf("a[%d]=%d ",i,a[i]);
    }
    printf("\n");
    printf("=======================\n");
    my_memset(a,0,2);
    for(i = 0;i < 10;i++)
    {
        printf("a[%d]=%d ",i,a[i]);
    }
    printf("\n");
    return 0;
}

（12）strstr函数

函数原型： char *strstr(const char *haystack, const char *needle);

功能：函数用于判断字符串needle是否是haystack的子串。如果是，则该函数返回needle在haystack中首次出现的地址；否则，返回NULL。

代码实现：

#include <stdio.h>

char *my_strstr(const char *haystack, const char *needle)
{
    const char *ph;
    const char *pn;
    if(NULL == haystack || NULL == needle)
    {
        return NULL;
    }
    while('\0' != *haystack)
    {
        ph = haystack;
        pn = needle;
        do{
            if('\0' == *pn)
            {
                return (char *)haystack;
            }
        }while(*ph++ == *pn++);
        haystack++;
    }
    return NULL;    
}

int main()
{
    const char *a = "Hello,World!";
    const char *b = "ll";
    const char *ret = NULL;
    
    ret = my_strstr(a,b);
    printf("%s\n",ret);
    return 0;
}


自己实现string函数功能
09-04
自己实现一个string函数！其中包括strcat，strcpy的编写！
整理Python 常用string函数(收藏)
12-25
字符串中字符大小写的变换 1. str.lower() //小写 >>> ‘SkatE’.lower() ‘skate’ 2. str.upper() //大写 >>> ‘SkatE’.upper() ‘SKATE’ 3. str.swapcase() //大小写互换 >>> ‘SkatE’.swapcase() ...
string函数的实现
weixin_44077227的博客
04-12 561
strcpy 函数的实现 #include<stdio.h> #include <assert.h> char* Strcpy(char* dest,const char* src) { int i; char* ret = dest; assert(src!= NULL); assert(dest!= NULL); for(i = 0;src[i]!='\0';...
string部分函数实现
weixin_52822783的博客
03-23 1427
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、三种方法实现函数strlen1、计数器方法2、指针方法3、递归方法二、实现函数strcpy1、进阶版本2、普通版本三、实现函数strcat四、实现函数strcmp五、实现函数strstr六、使用函数strtok七、实现函数memcpy八、实现函数memmove总结 前言 C语言给我们提供了很多函数库，今天让我们来模仿下string里面的部分函数吧！！！ 提示：以下是本篇文章正文内容，下面案例可供参考 一、三种方法实.
string系列函数实现
qq_41033011的博客
09-26 569
1. 写出完整版的strcpy函数 【要点】 将源字符串加上 const，表明为输入参数 对源地址和目的地址加上断言 为了实现链式操作，将目的地址返回 char *strcpy(char *dest, const char *src) { assert(dest != NULL && src != NULL); char *address = dest; while((*dest++ = *src++) != '/0'); return dest; } 2. 检查以下代码问
基于PHP常用文件函数和目录函数整理
10-19
本文将详细介绍几个常用的文件和目录函数，帮助开发者更好地理解和利用这些功能。 1. `basename()` 函数用于从路径中提取文件的基本名称。它接受两个参数，`path` 是文件的完整路径，`suffix` 是可选的文件扩展名。...
[整理版]ASP常用内置函数
01-02
函数，就是该语言封装了的一个功能块，以方便用户的调用。比如“now()”在VBScript中就是一个能显示出当前日期和时间的函数。至于具体为什么能显示，则是该语言内核所定的，用户只需明白“now()”就是用来能显示日期...
string函数的一些实现
weixin_30763397的博客
01-17 108
1 /************************************************************************* 2 > File Name: test.cpp 3 ************************************************************************/ 4 ...
String函数功能总结
征途开始的小窝(^_^)
05-23 762
1、find 原型如下： （1）size_t find (const string& str, size_t pos = 0) const;  //查找对象--string类对象 （2）size_t find (const char* s, size_t pos = 0) const; //查找对象--字符串 （3）size_t find (const char* s, siz
string函数实现
07-12
string函数实现 strlen.........
string中部分函数的实现方法
05-08
这是一个string基本功能的实现，包括strstr,strcpy等，
string函数的模拟实现
qqkb1016的博客
04-01 173
#include<stdio.h> #include<assert.h>size_t my_strlen(const char*str)//求字符串长度 { int length; for(length=0;*str!='\0';++length) { str++; } return length; }char *my_strcpy(char*
String类的函数实现
luoshasha1216的博客
01-29 272
普通构造函数/拷贝构造函数/析构函数/赋值运算符函数/+运算符函数/相等运算符函数/索引运算符函数/length函数/友元函数 class String { friend std::ostream& operator<<(std::ostream& os,const string& s);//友元函数 public: String(const char* str=NULL);//普通构造函数
深度剖析 string —— strlen & strtok
十里坡小白的博客
07-14 1018
深度剖析 string 库函数 —— 源码实现
string库函数实现
Amoralmmm的博客
08-23 262
1.实现strcpy void *Strcpy(char *dest, char *src) { assert(dest); assert(src); char *tmp = dest; while (*dest++ = *src++); dest = tmp; return dest; } 2.实现strcat void *Strcat(char *dest, char *src)...
实现常见的string函数
编程故事会
05-19 137
1.实现strcpy/* 1.实现strcpy */ char *my_strcpy(char *dest, const char *src) { char *ret = dest; assert(dest != NULL); assert(src != NULL); while ((*dest++ = *src++)){//赋值 ; } return ret; }2.实现str...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值