首页 > 其他分享 >经典C语言模拟字符串库操作

经典C语言模拟字符串库操作

时间：2023-06-02 15:36:10浏览次数：36  
标签：return dest ret C语言 char int 字符串 include 模拟


1.模拟strcpy(字符串拷贝函数)


#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
char *my_strcpy(char *dest,const char *src)  
{  
char *pc=dest;  
   assert(src);  
   assert(dest);  
while(*dest++ = *src++)  
   {  
      ;  
   }  
return pc;  
}  
int main()  
{  
char *pa="abcdef";  
char pb[10]={0};  
   my_strcpy(pb,pa);  
"%s\n",pb);  
"pause");  
return 0;  
}


strncpy:



#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
char *my_strncpy(char *dest,const char *src,size_t n)  
{  
char *ret=dest;  
   assert(src);  
   assert(dest);  
while(n--)  
   {  
       *ret++=*src++;  
   }  
'\0';//拷贝'\0'  
return dest;  
}  
int main()  
{  
int num = 0;  
char pa[]="abcdefgh";  
char pb[20]={0};  
char *ret=NULL;  
"请输入你要拷贝字符的个数:");  
"%d",&num);  
    ret=my_strncpy(pb,pa,num);  
"%s\n",ret);  
"pause");  
return 0;  
}

2.模拟strlen（求取字符串长度） 


//普通实现  
 
 
   
 
    
 
#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
int my_strlen(const char *src)  
{  
int count=0;  
   assert(src);  
while(*src++)  
   {  
      count++;  
   }  
return count;  
}  
int main()  
{  
int ret=0;  
char *pa="abcdefgh";  
   ret=my_strlen(pa);  
"所求字符串的长度为:%d\n",ret);  
"pause");  
return 0;  
}



//指针实现  
#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
  
int my_strlen(const char *str)  
{  
char *tmp=str;  
while(*tmp++)  
    {  
        ;  
    }  
return tmp-str-1;  
}  
int main()  
{  
char *pa="abcdefgh";  
int ret = my_strlen(pa);  
"%d\n",ret);  
"pause");  
return 0;  
}


//递归实现  
#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
  
int my_strlen(const char *str)  
{  
if(!*str)  
return 0;  
else  
return 1+my_strlen(str+1);  
}  
int main()  
{  
char *pa="abcdefgh";  
int ret = my_strlen(pa);  
"%d\n",ret);  
"pause");  
return 0;  
}



3.模拟strstr（在所给字符串中查找子串第一次出现的位置）



#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
  
char *my_strstr(const char *str,const char *dest)  
{  
char *tmp=NULL;  
const char *string1=str;  
const char *string2=dest;  
   assert(str);  
   assert(dest);  
if(!*string2)  
   {  
return (char *)string1;  
   }  
while(*string1)  
   {  
char *)string1;  
while(*string1 && *string2 && *string1==*string2)  
       {  
           string1++;  
           string2++;  
       }  
if(!*string2)  
       {  
return (char *)tmp;  
       }  
       string1++;  
   }  
return NULL;  
}  
int main()  
{  
int result=0;  
char *pa="abcdef";  
char *pb="cde";  
char *ret=my_strstr(pa,pb);  
   result=ret-pa+1;  
if(NULL != ret)  
   {  
"%s found at position %d\n",pb,result);  
   }  
else  
   {  
"%s not found\n",pb);  
   }  
     
"pause");  
return 0;  
}

strrstr:库中没有该函数，仿照strchrr实现（在所给字符串中查找子串最后一次出现的位置

<span style="font-size:14px;">#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
  
char *my_strstr(const char *dest,const char *src)  
{  
const char *tmp = NULL;  
    assert(dest);  
    assert(src);  
while(*dest && *src)  
    {  
        tmp=src;  
while(*src && *dest==*src)  
        {  
            src++;  
            dest++;  
        }  
if(!*dest)  
        {  
return (char*)tmp;  
        }  
        src++;  
    }         
return NULL;  
}  
int main()  
{  
char *pa = "adcbdcdcbef";  
char *pb = "dcb";  
char *ret = my_strstr(pb,pa);  
if(ret!=NULL)  
    {  
"%s\n",ret);  
    }  
else  
    {  
"没找到该子串\n");  
    }  
"pause");  
return 0;  
}</span><span style="font-size: 24px;">  
</span>


<span style="font-size:14px;">#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
  
char *my_strrstr(const char *dest,const char *src)  
{  
const char *psrc = NULL;  
const char *pdest = dest;  
const char *tmp = NULL;  
    assert(dest);  
    assert(src);  
while(*src)  
    {  
        psrc=src;  
while(*src && *dest==*src)  
        {  
            src++;  
            dest++;  
        }  
if(*dest == '\0')  
        {  
            tmp=psrc;  
        }  
        src=psrc;  
        dest=pdest;  
        src++;  
    }  
if(tmp!=NULL)  
    {  
return (char *)tmp;  
    }  
return NULL;  
}  
int main()  
{  
char *pa = "adcbdcb";  
char *pb = "dcb";  
char *ret = my_strrstr(pb,pa);  
if(ret!=NULL)  
    {  
"%s\n",ret);  
    }  
else  
    {  
"没找到该子串\n");  
    }  
"pause");  
return 0;  
}</span>

4.strcat(字符串连接) 


#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
char *my_strcat(char *dest,const char *src)  
{  
char *tmp=dest;  
  assert(dest);  
if(!*src)  
    {  
return tmp;  
    }  
while(*tmp)  
    {  
        tmp++;  
    }  
while(*tmp++ = *src++)  
    {  
        ;  
    }  
return dest;  
}  
int main()  
{  
char *pa="efgh";  
char pb[20]="abcd";  
   my_strcat(pb,pa);  
"%s\n",pb);  
"pause");  
return 0;  
}


<span style="font-size:14px;">#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
  
char *my_strstr(const char *dest,const char *src)  
{  
const char *tmp = NULL;  
    assert(dest);  
    assert(src);  
while(*dest && *src)  
    {  
        tmp=src;  
while(*src && *dest==*src)  
        {  
            src++;  
            dest++;  
        }  
if(!*dest)  
        {  
return (char*)tmp;  
        }  
        src++;  
    }         
return NULL;  
}  
char *my_strrstr(const char *dest,const char *src)  
{  
const char *tmp = NULL;  
const char *psrc=NULL;  
const char *pdest=dest;  
    assert(dest);  
    assert(src);  
while(*src)  
    {  
        tmp = my_strstr(pdest,src);  
if(tmp!=NULL)  
        {  
            psrc=tmp;  
            src=tmp;  
        }  
        src++;  
    }  
if(psrc!=NULL)  
    {  
return (char *)psrc;  
    }  
return NULL;  
}  
int main()  
{  
char *pa = "adcbdcb";  
char *pb = "dcb";  
char *ret = my_strrstr(pb,pa);  
if(ret!=NULL)  
    {  
"%s\n",ret);  
    }  
else  
    {  
"没找到该子串\n");  
    }  
"pause");  
return 0;  
}  
</span>

strncat:


#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
char *my_strncat(char *dest,const char *src,size_t n)  
{  
char *ret=dest;  
   assert(src);  
   assert(dest);  
while(*ret)  
   {  
       ret++;  
   }  
while(n--)  
   {  
       *ret++=*src++;  
   }  
'\0';//追加'\0'  
return dest;  
}  
int main()  
{  
int num = 0;  
char pa[20]="abcd";  
char pb[]="efgghhh";  
char *ret=NULL;  
"请输入你要追加字符的个数:");  
"%d",&num);  
    ret=my_strncat(pa,pb,num);  
"%s\n",ret);  
"pause");  
return 0;  
}



#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
#include<string.h>  
  
  
char *my_strrstr(const char *dest,const char *src)//从后向前查找  
{  
int len1=strlen(src);  
int len2=strlen(dest);  
const char*psrc=src;  
    assert(dest);  
    assert(src);  
while(src+len1-1>src)  
    {  
while(*psrc)//先找到最后位置  
        {  
            psrc++;  
        }  
while(*dest)//先找到最后位置  
        {  
            dest++;  
        }  
while(--len1 && --len2 && *dest==*psrc)  
        {  
            dest--;  
            psrc--;  
        }  
if(len2==0)  
return (char*)psrc-1;  
    }  
return NULL;  
}  
int main()  
{  
char *pa = "adcbdcb";  
char *pb = "dcb";  
char *ret = my_strrstr(pb,pa);  
if(ret!=NULL)  
    {  
"%s\n",ret);  
    }  
else  
    {  
"没找到该子串\n");  
    }  
"pause");  
return 0;  
}

5.strchr（在字符串中查找某个字符首次出现的位置）

#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
char *my_strchr(const char *src,int ch)  
{  
char *tmp=(char *)src;  
        assert(src);  
while(*tmp++)  
    {  
        src=tmp;  
if(*tmp == ch)  
        {  
return (char *)src;  
        }  
    }  
return NULL;  
}  
int main()  
{  
int ch='c';  
char *pa="abcdef";  
char *ret=my_strchr(pa,ch);  
int result=ret-pa+1;  
if(ret != NULL)  
   {  
"Result:\tfirst %c found at position %d\n\n", ch, result);  
   }  
else  
   {  
"Result:\t%c not found\n",ch);  
   }  
"pause");  
return 0;  
}

strrchr（在字符串中查找某个字符最后一次出现的位置）

<span style="font-size:18px;"><span style="font-size: 24px;">//从后向前找</span>  
</span>

<span style="font-size:14px;">#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
  
char *my_strrchr(const char *str,int ch)  
{  
const char *tmp = str;  
    assert(str);  
while(*str++)  
    {  
        ;  
    }  
while(--str>tmp)  
    {  
if(*str == ch)  
return (char *)str;  
    }  
return NULL;  
}  
int main()  
{  
char *pa = "adbdcdef";  
char *ret = my_strrchr(pa,'d');  
if(ret!=NULL)  
    {  
"%s\n",ret);  
    }  
else  
    {  
"没找到该字符\n");  
    }  
"pause");  
return 0;  
}</span>

//每次找到指定字符，先保存起来，最后返回该字符所在地址  
#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
  
char *my_strrchr(const char *str,int ch)  
{  
const char *tmp = NULL;  
    assert(str);  
while(*str)  
    {  
if(*str==ch)  
            tmp=str;  
        str++;  
    }  
if(tmp!=NULL)  
return (char*)tmp;  
return NULL;  
}  
int main()  
{  
char *pa = "adcbdcdef";  
char *ret = my_strrchr(pa,'g');  
if(ret!=NULL)  
    {  
"%s\n",ret);  
    }  
else  
    {  
"没找到该字符\n");  
    }  
"pause");  
return 0;  
}


//通过strchr实现  
#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
  
char *my_strchr(const char *str,int ch)  
{  
    assert(str);  
while(*str)  
    {  
if(*str == ch)  
return (char*)str;  
        str++;  
    }  
return NULL;  
}  
char *my_strrchr(const char *str,int ch)  
{  
char *tmp = NULL;  
    assert(str);  
while(*str)  
    {  
if(*str == ch)  
        tmp = my_strchr(str,ch);  
        str++;  
    }  
if(tmp!=0)  
return (char*)tmp;  
return NULL;  
}  
int main()  
{  
char *pa = "adcbdcdef";  
char *ret = my_strrchr(pa,'d');  
if(ret!=NULL)  
    {  
"%s\n",ret);  
    }  
else  
    {  
"没找到该字符\n");  
    }  
"pause");  
return 0;  
}

6.strcmp（字符串比较）

实现1：

#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
  
int my_strcmp(const char *str1,const char *str2)  
{  
    assert(1);  
    assert(2);  
while(*str1 && *str2==*str1)  
    {  
        str1++;  
        str2++;  
    }  
return *str1-*str2;  
}  
  
int main()  
{  
char *pa="abczef";  
char *pb="abcfgjdh";  
int ret=my_strcmp(pa,pb);  
if(ret>0)  
    {  
"%s greater than %s\n",pa,pb);  
    }  
else if(ret==0)  
    {  
"%s eaqul to %s\n",pa,pb);  
    }  
else  
    {  
"%s less than %s\n",pa,pb);  
    }  
"pause");  
return 0;  
}


实现2： 

#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
  
int my_strcmp(const char *str1,const char *str2)  
{  
int ret = 0;  
        assert(1);  
    assert(2);  
while(!(ret=*(unsigned char *)str1-*(unsigned char *)str2) && *str2)  
    {  
            ++str1;  
        ++str2;  
    }  
if(ret<0)  
    {  
return -1;  
    }  
else if(ret>0)  
    {  
return 1;  
    }  
return ret;  
}  
  
int main()  
{  
char *pa="abcdef";  
char *pb="abcfgjdh";  
int ret=my_strcmp(pa,pb);  
if(ret>0)  
    {  
"%s greater than %s\n",pa,pb);  
    }  
else if(ret==0)  
    {  
"%s eaqul to %s\n",pa,pb);  
    }  
else  
    {  
"%s less than %s\n",pa,pb);  
    }  
"pause");  
return 0;  
}

strncmp:

7.memcpy:内存拷贝函数（两块内存不关联） 

#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
int my_strncmp(const char *str1,const char *str2,size_t n)  
{  
   assert(str1);  
   assert(str2);  
while(--n)  
  {  
      *str1++ == *str2++;  
  }  
return (*str1-*str2);  
}  
int main()  
{  
int num = 0;  
int ret = 0;  
char *pa="abcd";  
char *pb="abcf";  
"请输入你要比较字符的个数:");  
"%d",&num);  
    ret=my_strncmp(pa,pb,num);  
if(ret>0)  
    {  
"%s greater than %s\n",pa,pb);  
    }  
else if(ret==0)  
    {  
"%s eaqul to %s\n",pa,pb);  
    }  
else  
    {  
"%s less than %s\n",pa,pb);  
    }  
"pause");  
return 0;  
}



#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
void *my_memcpy(void *dest,const void *src,size_t n)  
{  
char *pdest=(char *)dest;  
const char *psrc=(const char *)src;  
  assert(dest);  
    assert(src);  
while(n--)  
    {  
        *pdest++=*psrc++;  
    }  
return dest;  
}  
int main()  
{  
int i = 0;  
int arr1[20]={0};  
int arr2[]={1,2,3,4,5,6,7,8,9,0};  
int sz = sizeof(arr2)/sizeof(arr2[0]);  
    my_memcpy(arr1,arr2,sz);  
for(i=0; i<sizeof(arr2)/sizeof(arr2[0]); i++)  
    {  
"%d ",arr2[i]);  
    }  
"pause");  
return 0;  
}


memmove:(两块内存有关联) 

#define _CRT_SECURE_NO_WARNINGS 1  
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
  
void *my_memmove(void *dest,const void *src,size_t n)  
{  
char *pdest=(char *)dest;  
const char *psrc=(char *)src;  
    assert(dest);  
    assert(src);  
if(psrc+n>pdest && pdest>psrc)//从后向前拷贝  
    {  
while(n--)  
        {  
            *(pdest+n)=*(psrc+n);  
        }  
    }  
else//从前向后拷贝  
    {  
while(n--)  
         {  
             *pdest++=*psrc++;    
         }  
    }  
return dest;  
}  
int main()  
{  
int i = 0;  
int num = 0;  
int arr2[]={1,2,3,4,5,6,7,8,9,0};   
"请输入你要拷贝内存的大小:");  
"%d",&num);  
sizeof(int));  
for(i=0; i<sizeof(arr2)/sizeof(arr2[0]); i++)  
    {  
"%d ",arr2[i]);  
    }  
"\n");  
"pause");  
return 0;  
}

标签：return,dest,ret,C语言,char,int,字符串,include,模拟
From： https://blog.51cto.com/u_16147764/6402919

相关文章

  • Java官方笔记5数字和字符串
    NumbersNumber的子类：另外还有BigDecimal和BigInteger，用于高精度计算，AtomicInteger和AtomicLong用于多线程应用。我们有时候需要用包装类而非基本数据类型，理由如下：方法入参类型为Object，只能传入对象使用包装类提供的常量，比如MIN_VALUE和MAX_VALUE使用包装类的方法来做......
  • 俄罗斯方块-C语言-详注版
    俄罗斯方块-C语言-详注版概述本文详述了C语言版俄罗斯方块游戏的原理以及实现方法,对游戏代码进行了详细的分析和注释,通过本文能够让大家对WIN32编程框架有一个大致了解,对C语言运用有一定提高,同时也能给大家提供一个C语言小游戏编程的思路,也能完全够通过自己的实力去编写一个属......
  • 算法——字符串（一）
    1、给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。1classSolution{2publicintlengthOfLongestSubstring(Strings){3intlen=s.length();4intmax=0;5intright=0;6Set<Character>set=new......
  • C语言——指针
    指针的优点：使程序更简洁、紧凑、高效有效的表达更复杂的数据结构动态分配内存得到多于一个数的函数返回值1.指针的基本用法1.1指针的概念内存地址：内存中每个字节单位都有一个编号（一般用十六进制表示）指针：指针就是内存地址指针变量：用于存放地址的变量就叫做指针变量指针变量画图展......
  • C语言——运算符和表达式
    所谓表达式就是指由运算符、运算量和标点符号组成的有效序列，其目的是说明一个计算过程。表达式可以独立成语句：表达式;运算符按功能分为：算术运算、赋值运算、关系运算、逻辑运算、位运算以及其他运算符1.算术运算符：+-*/%++–（1）/：整数相除，向下取整。inta=3/2;floatb=3/2;fl......
  • 剑指 Offer 67. 把字符串转换成整数
    题目描述：写一个函数StrToInt，实现把字符串转换成整数这个功能。不能使用atoi或者其他类似的库函数。 首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合......
  • 十、python字符串str
    十、python字符串str1.字符串的定义与输入在python中,用引号引起来的都是字符串。还有input函数输入的，str()函数转换的等。string1="hello"string2='hello'string3="""hellopython"""string4='''helloworld'''string5=input(......
  • C语言数组
    数组概念在C语言中，数组属于构造数据类型。一个数组可以分解为多个数组元素，这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同，数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。从内存角度，是一片连续的内存空间数组初始化：//在编译时明确指定......
  • c语言结构体
    定义结构体变量structStudent{char*name;intage;intscore;};voidmain(){structStudentst1;system("pause");}#include<stdlib.h>#include<string.h>#include<stdio.h>typedefstructStudent{char*nam......
  • C语言链表
    #define_CRT_SECURE_NO_WARNINGS#include<stdlib.h>#include<string.h>#include<stdio.h>/*structTeacher{charname[64];intid;char*p;char**p2;};typedefstructTeacherTeacher;*/typedefstructStudent......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99