有关字符串的函数(strlen、strcat、strcpy、strcmp、strncat、strncpy、strncmp、 strchr、strrchr、strpbrk、strstr、strrstr、memcpy、memmove)


#pragma once

#include<assert.h>

#include<string.h>


//求取字符串的长度

//1. 利用递归方法实现 

int my_strlen1(char* p)

{

if(*p != '\0')

{

return 1+my_strlen1(p+1);

}

else

{

return 0;

}

}


//2. 利用计数法实现

int my_strlen2(char* p)

{

int count = 0;

assert(p);

while(*p)

{

count++;

p++;

}

return count;

}


//3. 利用指针实现

int my_strlen3(const char* p)

{

const char* ret = p;

assert(p);

while (*p)

{

p++;

}

return p-ret;

}


//实现字符串的拷贝(简便写法)

char *my_strcpy(char* dest,const char* src)//返回值设置为char*,以便于链式访问

{

char* ret = dest;

assert(dest);

assert(src);

while(*dest++ = *src++)

{

;

}

return ret;//返回第一个参数的一份拷贝,即一个指向目标字符串的指针

}


//连接字符串

char *my_strcat(char* dest,const char* src)//字符串的连接

{

char* ret = dest;

assert(dest);

assert(src);

while (*dest)

{

dest++;

}

while (*src)

{

*dest++ = *src++;

}

*dest = '\0';//结束标志

return ret;//返回第一个参数的一份拷贝,即一个指向目标字符串的指针

}


//字符串的比较

//如果str1小于str2,函数返回一个小于0的值,如果str1>str2,函数返回一个大于0的值,若两个字符串相等,返回0

int my_strcmp(const char* str1,const char* str2)

{

while (*str1 == *str2)

{

if(*str1 == '\0')

return 0;

str1++;

str2++;

}

return *str1 - *str2;

}


//长度受限的字符串函数

char* my_strncpy(char* dest,const char* src,size_t len)//拷贝长度为len的字符串

{

char* ret = dest;

assert(dest);

assert(src);

while(len--)

{

*dest = *src;

dest++;

src++;

}

*dest = '\0';

return ret;

}


//在目标字符串后面链接长度为len的字符串

char* my_strncat(char* dest,const char* src,size_t len)

{

char* ret = dest;

assert((dest != NULL)&&(src != NULL));

while(*dest != '\0')

{

dest++;

}

while ((len>0) && ((*dest++ = *src++) != '\0'))

{

len--;

}

*dest = '\0';

return ret;

}


//比较两个字符串,但他最多比较len个字节,如果两个字符串在第len个字符之前存在不相等的字符,则像strcmp一样停止比较,返回结果,如果两个字符串的前len个字符相等,则返回0

int my_strncmp(const char* str1,const char* str2,size_t len)

{

assert(str1);

assert(str2);

while (((len--)>0) && (*str1 != '\0') && (*str2 != '\0'))

{

if(*str1 == *str2)

{

str1++;

str2++;

}

else

{

return *str1 - *str2 - '\0';

}

}

return *str1 - *str2 - '\0';

}


//字符串查找

//该函数在字符串str中查找字符ch第一次出现的位置,若找到函数返回一个指向该位置的指针,反之,返回NULL

char* my_strchr(char* str,int ch)

{

char* ret = str;

assert(str);

while (*ret != '\0')

{

if(*ret == ch)

{

return ret;

}

ret++;

}

return NULL;

}


//该函数与strchr函数功能基本一致,只是他返回一个指向该字符串中该字符最后一次出现的位置(最右边的那个)

char* my_strrchr(char* str,int ch)

{

register char* last = NULL;

register char* current = NULL;

if(ch != '\0')//只有ch不为空字符才可以进行查找

{

current = my_strchr(str,ch);

while (current != NULL)

{

last = current;

current = my_strchr(last+1,ch);

}

}

return last;

}


//该函数返回一个指向str中第一个匹配group中任何一个字符的字符位置,若没找到,返回NULL

char* my_strpbrk(char* str,char* group)

{

register char* s1 = str;

register char* s2 = group;

assert(str);

assert(group);

while (*s1 != '\0')

{

while (*s2 != '\0')

{

if(*s1 == *s2)

{

return s1;

}

s2++;

}

s2 = group;

s1++;

}

}


//在str1中查找整个str2第一次出现的起始位置,并返回一个指向该位置的指针

char* my_strstr(char* str1,char* str2)//查找子字符串

{

char* ptr = str1;

char* p1 = NULL;

char* p2 = NULL;

while (*ptr)

{

p1 = ptr;

p2 = str2;

while (*p1 == *p2)

{

++p1;

++p2;

if(*p2 == '\0')

{

return ptr;

}

}

ptr++;

}

return NULL;

}


//在字符串s1中查找字符串s2最右出现的位置,并返回一个指向该位置的指针

char* my_strrstr(char* s1,char* s2)

{

register char* last = NULL;

register char* current = NULL;

//把指针初始化为我们已找到的前一次匹配的位置

//只在第二个字符串不为空时才进行查找,如果为空,返回NULL

if(*s2 != '\0')

{

current = my_strstr(s1,s2);

//我们每次找到字符串时,让指针指向他的起始位置,然后查找该字符串下一个匹配位置

while (current != NULL)

{

last = current;

current = my_strstr(last+1,s2);

}

}

//返回指向我们找到的最后一次匹配的起始位置的指针

return last;

}


//内存拷贝函数

void* memcpy(void* buf1,void* buf2,int count)

{

char* dest = (char*)buf1;

char* src = (char*)buf2;

assert(buf1);

assert(buf2);

while (count--)

{

*dest++ = *src++;

}

return buf1;

}


//必须考虑内存是否有重叠

void* memmove(void* buf1,const void* buf2,int count)

{

char* dest = (char*)buf1;

char* src = (char*)buf2;

assert(buf1);

assert(buf2);

if(dest>src && dest<(src+count))

{

while (count--)

{

*(dest+count) = *(src+count);

}

}

else

{

while (count--)

{

*dest++ = *src++;

}

}

return buf1;

}