模拟常见的字符操作函数

最新推荐文章于 2022-04-08 14:42:52 发布
最新推荐文章于 2022-04-08 14:42:52 发布
阅读量8.5k 收藏 3
点赞数 1
分类专栏： C语言 C语言之旅
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/snow_5288/article/details/52003827
版权
本文探讨了如何模拟实现C语言中的几个常见字符操作函数，包括strcpy字符串拷贝，strncpy安全拷贝，strstr查找子串首次出现位置，strchr和strrchr查找特定字符的首次和最后一次出现，以及strcmp和strncmp进行字符串比较。通过这些实现，可以更好地理解和掌握C语言字符串处理的基本原理。
摘要由CSDN通过智能技术生成

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);
   printf("%s\n",pb);
   system("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++;
   }
   *ret='\0';//拷贝'\0'
   return dest;
}
int main()
{
	int num = 0;
    char pa[]="abcdefgh";
	char pb[20]={0};
	char *ret=NULL;
	printf("请输入你要拷贝字符的个数:");
	scanf("%d",&num);
	ret=my_strncpy(pb,pa,num);
	printf("%s\n",ret);
	system("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);
   printf("所求字符串的长度为:%d\n",ret);
   system("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);
	printf("%d\n",ret);
	system("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);
	printf("%d\n",ret);
	system("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)
   {
	   tmp=(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)
   {
      printf("%s found at position %d\n",pb,result);
   }
   else
   {
      printf("%s not found\n",pb);
   }
   
   system("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;
}
int main()
{
    char *pa = "adcbdcdcbef";
	char *pb = "dcb";
	char *ret = my_strstr(pb,pa);
	if(ret!=NULL)
	{
	    printf("%s\n",ret);
	}
	else
	{
	    printf("没找到该子串\n");
	}
	system("pause");
	return 0;
}</span><span style="font-size: 24px;">
</span>
 

 

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

 

<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)
	{
	    printf("%s\n",ret);
	}
	else
	{
	    printf("没找到该子串\n");
	}
	system("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);
   printf("%s\n",pb);
   system("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)
	{
	    printf("%s\n",ret);
	}
	else
	{
	    printf("没找到该子串\n");
	}
	system("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++;
   }
   *ret='\0';//追加'\0'
   return dest;
}
int main()
{
	int num = 0;
    char pa[20]="abcd";
	char pb[]="efgghhh";
	char *ret=NULL;
	printf("请输入你要追加字符的个数:");
	scanf("%d",&num);
    ret=my_strncat(pa,pb,num);
	printf("%s\n",ret);
	system("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)
	{
	    printf("%s\n",ret);
	}
	else
	{
	    printf("没找到该子串\n");
	}
	system("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)
   {
	   printf("Result:\tfirst %c found at position %d\n\n", ch, result);
   }
   else
   {
       printf("Result:\t%c not found\n",ch);
   }
   system("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)
	{
	    printf("%s\n",ret);
	}
	else
	{
	    printf("没找到该字符\n");
	}
	system("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)
	{
	    printf("%s\n",ret);
	}
	else
	{
	    printf("没找到该字符\n");
	}
	system("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)
	{
	    printf("%s\n",ret);
	}
	else
	{
	    printf("没找到该字符\n");
	}
	system("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)
	{
	   printf("%s greater than %s\n",pa,pb);
	}
	else if(ret==0)
	{
	   printf("%s eaqul to %s\n",pa,pb);
	}
	else
	{
	   printf("%s less than %s\n",pa,pb);
	}
	system("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)
	{
	   printf("%s greater than %s\n",pa,pb);
	}
	else if(ret==0)
	{
	   printf("%s eaqul to %s\n",pa,pb);
	}
	else
	{
	   printf("%s less than %s\n",pa,pb);
	}
	system("pause");
	return 0;
}
 

strncmp:
 

 

#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";
	printf("请输入你要比较字符的个数:");
	scanf("%d",&num);
    ret=my_strncmp(pa,pb,num);
	if(ret>0)
	{
	   printf("%s greater than %s\n",pa,pb);
	}
	else if(ret==0)
	{
	   printf("%s eaqul to %s\n",pa,pb);
	}
	else
	{
	   printf("%s less than %s\n",pa,pb);
	}
	system("pause");
	return 0;
}
 

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

 

 

#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++)
	{
	    printf("%d ",arr2[i]);
	}
	system("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}; 
	printf("请输入你要拷贝内存的大小:");
	scanf("%d",&num);
        my_memmove(arr2+3,arr2+1,num*sizeof(int));
	for(i=0; i<sizeof(arr2)/sizeof(arr2[0]); i++)
	{
	    printf("%d ",arr2[i]);
	}
	printf("\n");
	system("pause");
	return 0;
}
 

 

 

 

 


 
 

 

                

        

        

    

  


    

      

        

            

              
                
                  snow_5288
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
字符串操作函数

				
			

			

				

					m0_54489492的博客
				

				

					02-23
					
					1918
					
				

			

		

		

			
				
文章目录字符串操作函数一、字符串操作函数1、strlen（）函数说明与模拟实现2、strcpy（）函数说明与模拟实现二、使用步骤1.引入库2.读入数据总结

字符串操作函数
提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

提示：以下是本篇文章正文内容，下面案例可供参考
一、字符串操作函数
在C语言程序库中为我们提供了多个字符串操作函数，这些函数的原型包含在string.h头文件中。其中最常用

			
		

	



                

              
                



	

		

			

				
					
常用字符串操作函数

				
			

			

				

					weixin_30849591的博客
				

				

					08-31
					
					98
					
				

			

		

		

			
				
一．就构成单元字符而言
1. 求字符串长度：int StrLength (s)
2. 在某元素前插入一个字符：int InsertStr (s,e,char a)
3. 在某字符后加入一个字符：int InsertStr(s,e,char a)
4. 删除一个字符：int Get(s,char a)
5. 判断是否有某个字符：int Index (s,e)
6. 找与已给字...

			
		

	



                


  
              

                


	

		

			

				
					
常见字符串操作函数

				
			

			

				

					Abner
				

				

					10-18
					
					410
					
				

			

		

		

			
				
转载自http://blog.csdn.net/h971379154/article/details/48846755
//常见字符串操作函数内部实现
#include 


size_t strlen(const char *s)//char型指针间距可表示长度
{
    const char *sc;
    for (sc = s; *sc != '\0'; ++sc);
    ret

			
		

	





	

		

			

				
					
常用字符串处理函数

				
			

			

				

					xiaoming_32的博客
				

				

					10-19
					
					322
					
				

			

		

		

			
				
1626-5-刘小铭总结《2016年10月19日》【连续19天总结】

标题：常用字符串处理函数

关键词：函数了解

内容：

         A、一句话概括今日目标完成情况

             常用字符串处理函数：80%

         B、具体内容：

                                昨天看了string字符串那一节课

			
		

	



		

			
		



	

		

			

				
					
常见内存拷贝函数：memcpy()、memmove()、strcpy()的实现及区别

				
			

			

				

					u011980566的博客
				

				

					05-05
					
					1185
					
				

			

		

		

			
				
转载：http://blog.163.com/xychenbaihu@yeah/blog/static/132229655201322332592/

memcpy和memmove实现不同测试：

memcpy不考虑内存重合问题：

       即src

       所以memcpy是正向copy n个字节的内容。

memmove考虑内存重合问题：

       

			
		

	





	

		

			

				
					
常见字符串函数及模拟字符串函数

				
			

			

				

					欢迎来到我的博客，在这里我会用我的方式来讲解知识，请大家多多关照
				

				

					01-30
					
					1329
					
				

			

		

		

			
				
strlen函数介绍及模拟实现



strlen：用来求字符串长度的函数

字符串以\0结尾，strlen是计算\0前面的字符串长度不包含\0，例如字符串"abcdef"包含a,b,c,d,e,f,\0 但strlen计算的答案不包含\0，所以长度为6；


strlen参数为常量字符串，指针指向的内容不可变（因为求字符串长度不需要改变字符串）；
	strlen返回值为无符号数。


如果为避免出现上述错误我们应该避免相减判断。以后要时时刻刻注意strlen返回值为无符号数。

模拟实现str...

			
		

	





	

		

			

				
					
常见的字符串操作函数详解

				
			

			

				

					weixin_58004346的博客
				

				

					09-17
					
					1914
					
				

			

		

		

			
				
文章目录字符串操作函数实现详解一、模拟实现strlen函数1.strlen原型2.strlen功能3.strlen 实现的方法和思路A.暴力求解B.递归方法C.指针—指针二、模拟实现strcpy（）1.函数原型2.函数的功能3.strcpy的实现4. strncpy的实现三、strcat()函数1.函数声明原型2. 函数功能3.strcat的实现4.strncat四、Strcmp1.strcmp的原型2. 函数的功能3.strcmp的实现4.strncmp五、Strstr1.函数原型2.函数的功能：3.函数

			
		

	





	

		

			

				
					
C字符串函数对应的C++ string操作详解

				
			

			

				

					12-20
				

			

		

		

			
				
本篇文章将详细解析C字符串函数如何在C++中用`std::string`类的方法进行等效操作。  1. `strcpy`: C中的`strcpy`函数用于复制一个字符串到另一个字符串。在C++中，我们可以使用`std::string`的`substr()`函数来达到...

			
		

	





	

		

			

				
					
C语言字符串函数strcmp的详解使用和模拟

					
最新发布

				
			

			

				

					12-23
				

			

		

		

			
				
 这个模拟版的`strcmp`函数按照相同的方式比较两个字符串，但在字符串不完全相等时返回了适当的值。  5. **注意事项**：  - `strcmp`不会忽略空格，所以"hello world"和"hello"在`strcmp`的比较下是不同的字符串。  ...

			
		

	





	

		

			

				
					
C语言：字符串操作函数与字符操作函数

				
			

			

				

					weixin_55547460的博客
				

				

					03-21
					
					1407
					
				

			

		

		

			
				
字符串的多种形式
1.字符数组形式（不写元素个数）
	char str1[] = { 'a','b','c' };
	char str2[] = { "abc" };
	char str3[] = "abc";



可见在不写数组元素个数，只写[ ]时，str1不会在后面自动补充\0
在写成字符串时可自动补\0


2.字符数组形式（写元素个数）
	char str1[3] = { 'a','b','c' };
	char str2[4] = { 'a','b','c' };

	char str3[3]

			
		

	





	

		

			

				
					
C语言拯救者（模拟实现字符串函数和内存函数--11）

				
			

			

				

					我心如火
				

				

					04-08
					
					2780
					
				

			

		

		

			
				
C语言没有字符串类型，字符串通常存放在常量字符串或者字符数组中。字符串库函数和内存函数的使用和注意事项，模拟库函数及详解






			
		

	





	

		

			

				
					
字符串的while()循环遍历

				
			

			

				

					荣子的专栏
				

				

					04-16
					
					1万+
					
				

			

		

		

			
				
下面是两种遍历字符串时的while()循环
char *str1 = "abcdefg";
char *str2 = "abcdefg";

//第一种遍历
while (*(str++)) {
    ;
}

//第二种遍历
while (*str2) {
    ;
    str2++;
}

经验判断, 最好用第二种遍历.下面是采用两种遍历的程序, 采用第一种遍历的程序输出结果错误

			
		

	





	

		

			

				
					
（C语言版）猴子吃桃问题

					
热门推荐

				
			

			

				

					snow_5288的博客
				

				

					09-17
					
					12万+
					
				

			

		

		

			
				
问题描述：
/*有一群猴子，去摘了一堆桃子*/
/*商量之后决定每天吃剩余桃子的一半*/
/*当每天大家吃完桃子之后，有个贪心的小猴都会偷偷再吃一个桃子*/
/*按照这样的方式猴子们每天都快乐的吃着桃子*/
/*直到第十天，当大家再想吃桃子时，发现只剩下一个桃子了*/
问：猴子们一共摘了多少桃子

			
		

	





	

		

			

				
					
C语言正序输出输出一个整数的每一位

				
			

			

				

					snow_5288的博客
				

				

					07-26
					
					1万+
					
				

			

		

		

			
				
//递归实现
#define _CRT_SECURE_NO_WARNINGS 1 
#include
#include

void print(int n)
{
    if(n<0)
       n=-n;
    if(n>=10)
		print(n/10);
	printf("%d ",n%10);
}
int main()
{
	int num = 0;
	printf("请输入一个整

			
		

	





	

		

			

				
					
操作符的秘密

				
			

			

				

					snow_5288的博客
				

				

					07-10
					
					5849
					
				

			

		

		

			
				
一 ：操作符
1.1：算术操作符
                           
+     -     *      /      %


注意：1.取%的两个操作数必须为整数类型。
           2.两个操作数中只要有一个为浮点型数据，则结果为浮点型。


1.2:移位操作符
      
左移位操作





右移位操作>>：
（一）逻辑

			
		

	





	

		

			

				
					
C语言模拟实现C++的继承与多态

				
			

			

				

					snow_5288的博客
				

				

					04-16
					
					4618
					
				

			

		

		

			
				
一、面向过程编程与面向对象编程的区别 
       众所周知，C语言是一种典型的面向过程编程语言，而C++确实在它的基础上改进的一款面向对象编程语言，那么，面向过程与面向对象到底有什么样的区别呢？【从设计方法角度看】 
面向过程程序设计方法采用函数（或过程）来描述对数据的操作，但又将函数与其操作的数据分离开来。  
面向对象程序设计方法是将数据和对象的操作封装在一起，作为一个整体来处理。【从维护角

			
		

	





	

		

			

				
					
详解交换两个数的值

				
			

			

				

					snow_5288的博客
				

				

					05-21
					
					4188
					
				

			

		

		

			
				
见到这道题，可能你会想到小时候玩过的游戏，将分别装有酱油和醋的两个瓶子交换，醋装到酱油瓶子里，酱油装到醋瓶子里，我们都知道，交换的过程需要家住一个空瓶子，当然，我们这道题也是同样的道理，需要创建一个临时变量来辅助交换。下面看具体的代码实现：
#include//程序中用到输出函数printf,所以需要引其对应的头文件
#include//system的头文件
int main()
{
   in

			
		

	





	

		

			

				
					
c语言字符串替换函数模拟实现

				
			

			

				

					07-25
				

			

		

		

			
				
C语言中没有内置的字符串替换函数，但我们可以通过模拟实现一个字符串替换函数。  首先，我们可以定义一个函数，该函数接受三个参数：源字符串、待替换的子字符串、替换后的子字符串。函数的返回值是替换完成后的...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值