C基础（41——45）

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

char* Strcat(char * s1,char* s2)
{
                 assert(s1 );
                 assert(s2 );
                 char* tmp=s1 ;

                 while(*tmp!='\0' )  //注意此处不能用while(*tmp++!='\0');因为这样的话，到最后tmp指向的是'\0'的下一个位置，而不是'\0'
                {
                                tmp++;
                }
                 //出来tmp指向'\0',然后执行下一条语句，就把'\0'覆盖了
                 while((*tmp++=*s2 ++)!='\0')
                                ;

                 return s1 ;
}
void test()
{
                 char str1[100]="hello " ;
                 char str2[100]="world" ;

                printf( "%s\n",Strcat(str1,str2));
}
int main()
{
                test();
                system( "pause");
                 return 0;
}

结果：

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

int Strcmp(const char* str1,const char* str2)
{
                 assert(str1 );
                 assert(str2 );

                 while(*str1 || *str2)
                {
                                 if(*str1 >*str2)
                                                 return *str1 -*str2;
                                 else if (*str1<* str2)
                                                 return *str1 -*str2;
                                 else
                                {
                                                 str1++;
                                                 str2++;
                                }
                }
                 return 0;
}

//库函数的实现
//int Strcmp(const char* str1,const char* str2)
//{
//             while(*str1==*str2)
//             {
//                             if(*str1=='\0')
//                                             return 0;
//
//                             str1++;
//                             str2++;
//             }
//
//             //不相等
//             return *str1-*str2;
//}
void test()
{
                 char* s1="abcde" ;
                 char* s2="abcd" ;

                printf( "%d\n",Strcmp(s1,s2));
}
int main()
{
                test();
                system( "pause");
                 return 0;
}

结果：

memcpy：从src所指的内存地址的起始位置开始，拷贝n个字节到目标dst所指的内存的起始位置

它没有考虑内存重叠的问题，所以出现了memmove()，memmove考虑到了内存重叠的问题。

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

void* Memcpy(void * dst,const void* src,size_t n)
{
                 assert(dst );
                 assert(src );

                 char* pdst=(char *)dst;
                 const char * s = (char*)src;

                 while(n --)
                {
                                *pdst++=*s++;
                }

                 return dst ;
}
void test()
{
                 char dst[100]="hello  world" ;
                 char* src="change myself" ;

                printf( "%s\n",Memcpy(dst,src,6));
}
int main()
{
                test();
                system( "pause");
                 return 0;
}

结果：

memmove()：从src拷贝n个字节到dst，memmove保证在原串被覆盖之前，将重叠区域的字节拷贝到目标区域中。但覆盖后src内容会被修改。但当目标区域和原区域没有重叠时，则和memcopy()函数功能相同

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

void* Memmove(void * dst,void* src,size_t n)
{
                 assert(dst );
                 assert(src );

                 char* pdst=(char *)dst;
                 char* psrc=(char *)src;

                 if(psrc<pdst && psrc+n >pdst)  //内存重叠，倒着拷贝
                {
                                psrc=psrc+ n-1;
                                pdst=pdst+ n-1;

                                 while(n --)
                                {
                                                *pdst--=*psrc--;
                                }
                }
                 else  //内存没有重叠，正常拷贝，等同于memcpy
                {
                                 while(n --)
                                {
                                                *pdst++=*psrc++;
                                }
                }

                 return dst ;
}
void test()
{
                 char str1[100]="hello" ;
                 char str2[100]="hello world" ;

                printf( "%s\n",Memmove(str1+2,str1,6));  //测试倒着拷贝hello
                printf( "%s\n",Memmove(str2,str2+6,6));  //测试正常拷贝，将'\0'也拷进去了,所以结果是world
                 //printf("%s\n",Memmove(str2,str2+6,5));  //测试正常拷贝，没有将'\0'拷贝进去，所以结果是world world
}
int main()
{
                test();
                system( "pause");
                 return 0;
}

结果：

memset：将已开辟内存空间的s的前n个字节用ch替换，并返回s

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#define N 10

void* Memset(void * s,int ch,size_t n)
{
                 assert(s );

                 char* ps=(char *)s;

                 while(n --)
                {
                                 if(*ps)
                                                *ps++= ch;
                }

                 return s ;
}
void test()
{
                 int arr[N ];
                Memset(arr,0, sizeof(arr));

                 for(int i=0;i<N;i++)
                {
                                printf( "%d ",arr[i]);
                }
                printf( "\n");
}
int main()
{
                test();
                system( "pause");
                 return 0;
}

结果：

本文出自 “追寻内心的声音” 博客，请务必保留此出处http://ljy789.blog.51cto.com/10697684/1833888