有關字符串中的函數及其部分面試題

    有關字符串的函數（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;

}