字符函数和内存函数的模拟实现

1.字符串函数 长度不受限的函数 1.1strlen函数

字符串已经''作为结束标志，strlen函数返回的是在字符串中''前面出现的字符个数（不包含'')。参数指向的字符串必须要以''结束。

模拟实现：

size_t my_strlen1(const char*str)//const保证了字符串的内容不可以更改
{
    assert(str);//断言，防止出现NULL指针
    int cnt=0;
    while(*str)
    {
        cnt++;
        str++;    
    }
    return cnt
}
size_t my_strlen2(const char*str)
{
    
}
int main()
{
    int len=my_strlen("abcdef");
    printf("%dn",len)
    return 0;
}

1.2.strcpy函数

char* strcpy(char * destination, const char * source )

源字符串必须以''结束。

会将源字符串中的''拷贝到目标空间。

目标空间必须足够大，以确保能存放源字符串。

目标空间必须可变。

char* my_strcpy(char*dest,const char*src)
{
    assert(dest&&src);
    char*ret=dest;
    while(*dest++=*src++)
    {
        ;    
    }
    return ret;
}
int main()
{
    char arr1[]="abcdef";
    char arr2[20]={0};
    my_strcpy(arr2,arr1);
    return 0;
}

1.3 strcat函数

char * strcat ( char * destination, const char * source );

源字符串必须以''结束。

目标空间必须有足够的大，能容纳下源字符串的内容。

目标空间必须可修改。

char* my_strcat(char*dest,const char*src)
{
    char* ret=dest;
    assert(dest&&src);
    while(*dest)
    {
        dest++;    
    }
    while(*dest++=*src++)
    {
        ;    
    }
    return ret;
}
int main()
{
    char arr1[30]="hello";
    char arr2[]="world";
    my_strcat(arr1,arr2);
    return 0;
}

1.4 strcmp

int strcmp ( const char * str1, const char * str2 );

第一个字符串大于第二个字符串，则返回大于0的数字

第一个字符串等于第二个字符串，则返回0

第一个字符串小于第二个字符串，则返回小于0的数字

这里的比较是依次比较字符的ASCII码值

int my_strcmp(const char*str1,const char*str2)
{
    assert(str1&&str2);
    while(*str1==*str2)
    {
        if(*str1=="")
            rerturn 0;
        str1++;
        str2++;    
    }
    return *str1-*str2;
}
int main()
{
    char arr1[]="abe";
    char arr2[]="abq";
    int ret=my_strcmp(arr1,arr2);
    return 0;
}

长度受限的函数 2.1.strncpy函数

char * strncpy ( char * destination, const char * source, size_t num );

拷贝num个字符从源字符串到目标空间。

如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

char*my_strncpy( char * destination, const char * source, size_t num )
int main()
{
    char arr1[]="xxxxxxxxxxxxxxx";
    char arr2[]="hello world";
    my_strncpy(arr1,arr2,n);
    return 0;
}

2.2strncat函数

char * strncat ( char * destination, const char * source, size_t num );

其他字符串函数 3.1.strstr函数

返回字符串的起始位置；

char * strstr ( const char *str2, const char * str1);

BF算法模拟实现：

char* my_strstr(const char*str,const char*substr)
{
    const char*s1=str;
    const char*s2=substr;
    char*cur=str
    assert(str&&substr);
    if(*substr=="")
        return str;
        while(*cur)
        {
            s1=cur;
            s2=substr;
            while(*s1&&*s2&&*s1==*s2)
            {
                s1++;
                s2++;            
            }
            if(*s2=="")
                return cur;                                                        
           cur++;
        }        
        return NULL;
}

KMP算法实现

KMP算法的核心是利用匹配失败后的信息，尽量减少模式串与主串的匹配次数以达到快速匹配的目的。具体的实现是通过nest()函数实现。

 

//str代表主串
//sub代表子串
//pos代表从主串的pos位置开始找
void getnext(char*sub,int* next,int lensub)
{
    next[0]=-1;
    next[1]=0;
    int i=2;//当前的i
    int k=0;//前一项的k
    while(i=lenstr)
        return -1;
    int* next=(int*)malloc(sizeof(int)*lensub)
    assert(next);
    getnext(sub,next,lensub);
    int i=pos;//遍历主串
    int j=0;//遍历子串
    while(i=lensub)
    {
        return i-j;    
    }
    return -1;
}

 2.2strtok字符串分割函数

1.sep参数是个字符串，定义了用作分隔符的字符集合第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。

2.strtok函数找到str中的下一个标记，并将其用结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）

3.strtok函数的第一个参数不为NULL，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。

4.strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。

如果字符串中不存在更多的标记，则返回NULL指针。

//strtok函数找第一个标记的时候，函数的第一个指针不为NULL；
//strtok找后面的标记的时候，函数的第一个参数为NULL;
//利用for循环初始化一次的特点
#include 
int main()
{   
    char *p = "helloworld@www.com;"; 
    const char* sep = ".@"; 
    char arr[30]; char *str = NULL; 
    strcpy(arr, p);//将数据拷贝一份，处理arr数组的内容 
    for(str=strtok(arr, sep); str != NULL; str=strtok(NULL, sep)) 
    { 
    printf("%sn", str); 
    }
 }

3.3.strerror函数错误调用信息

char * strerror ( int errnum );

//返回错误码，所对应的错误信息
//c语言中规定了一些错误信息，每一种错误码对应一种错误信息
//把错误码翻译成错误信息
//C语言打开文件
int main ()
{  
    FILE * pFile;  
    pFile = fopen ("unexist.ent","r");  
    //fclose文件关闭函数
    if (pFile == NULL)    
    printf ("Error opening file unexist.ent: %sn",strerror(errno));    
    //errno: Last error number  
    return 0;
}
    Edit & Run
//当库函数使用的时候，发生错误会把errno这个全局的错误变量
//设置为本次执行库函数产生的错误码
//errno是C语言提供的一个全局变量，可以直接使用，放在errno.h文件中

头文件#include

int tolower(int c)//转化为小写字母
int toupper(int c)//转化为大写字母

 内存函数 1.memcpy

void * memcpy ( void * destination, const void * source, size_t num );

1.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。

2.这个函数在遇到''的时候并不会停下来。

3.如果source和destination有任何的重叠，复制的结果都是未定义的。

void* my_memcpy(void* dest,const void*src,size_t num)
{
    void*ret=dest;
    assert(dest&&src);
    //一个字节一个字节的拷贝
    while(num--)
    {
        *(char*)dest=*(char*)src
        //强制类型转化都是临时进行的，在使用后就转化为原来的类型
        dest=(char*)dest+1;
        src=(char*)src+1;
     }
        return ret;
}

2.memset内存初始化函数

int main()
{
    chararr[20]={ 0 };
    memset(arr,'x',5*szieof(arr[0]));
    return 0;
}

3.memmove

void * memmove ( void * destination, const void * source, size_t num );

1.和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。

2.如果源空间和目标空间出现重叠，就得使用memmove函数处理。

3.因此进行比较，memmove的功能完全包含了memcpy的功能，直接使用memmove功能就行

//通过判断重叠部分的位置
//有两种move方式，一种是从前向后，一种是从后向前
void* my_memmove(void* dest,const void* src,size_t num)
{
    void*ret=dest;
    assert(dest&&src);
    if(dest