string.h函数源码
strstr()函数源码
/*
得到s1中第一次包含s2字符串的位置指针。
*/
#include <stdlib.h>
char * my_strstr(const char *s1,const char *s2)
{
if (*s1 == 0)
{
if (*s2)
return (char *) NULL;
return (char *) s1;
}
while (*s1)
{
size_t i;
i = 0;
while (1)
{
if (s2[i] == 0)
{
return (char *) s1;
}
if (s2[i] != s1[i])
{
break;
}
i++;
}
s1++;
}
return (char *) NULL;
}
int main()
{
char *str1 = "ammana_babi";
char *str2 = "babi";
char *p;
if( (p = my_strstr(str1,str2)) == NULL)
printf("Can't find the string /"%s/"!/n",str2);
else
printf("Find the string /"%s/"!/n",p);
str1 = "abc";
str2 = "def";
if( (p = my_strstr(str1,str2)) == NULL)
printf("Can't find the string /"%s/"!/n",str2);
else
printf("Find the string /"%s/"!/n",p);
system("pause");
return 0;
}
strpbrk()函数源码
/*
得到s1中第一个且是s2中字符的位置指针。
*/
#include <stdlib.h>
char * my_strpbrk(const char *s1 ,const char *s2)
{
const char *c = s2;
if (!*s1)
return (char *) NULL;
while (*s1)
{
for (c = s2; *c; c++)
{
if (*s1 == *c)
break;
}
if (*c)
break;
s1++;
}
if (*c == '/0')
s1 = NULL;
return (char *) s1;
}
int main()
{
char *str1 = "ammana_babi";
char *str2 = "babi";
char *p;
if( (p = my_strpbrk(str1,str2)) == NULL)
printf("No same character!/n");
else
printf("%c/n",*p);
str1 = "abc";
str2 = "def";
if( (p = my_strpbrk(str1,str2)) == NULL)
printf("No same character!/n");
else
printf("%c/n",*p);
system("pause");
return 0;
}
strcspn()函数源码
/*
得到s1中第一个且是s2中字符的字符位置。
*/
int my_strcspn(const char *s1 ,const char *s2)
{
const char *s = s1;
const char *p;
while (*s1)
{
for (p = s2; *p; p++)
{
if (*s1 == *p)
break;
}
if (*p)
break;
s1++;
}
return s1 - s;
}
int main()
{
char *str1 = "ammana_babi";
char *str2 = "babi";
int offset;
if((offset = my_strcspn(str1,str2)) >= strlen(str1))
printf("Can't find the same character!/n");
else
printf("%c/n",*(str1 + offset));
str1 = "abc";
str2 = "def";
if((offset = my_strcspn(str1,str2)) >= strlen(str1))
printf("Can't find the same character!/n");
else
printf("%c/n",*(str1 + offset));
system("pause");
return 0;
}
strspn()函数源码
/*
得到s1中第一个且不是s2中任意字符的字符位置。
*/
int my_strspn(const char *s1 ,const char *s2)
{
const char *s = s1;
const char *p;
while (*s1)
{
for (p = s2; *p; p++)
{
if (*s1 == *p)
break;
}
if (*p == '/0')
break;
s1++;
}
return s1 - s;
}
int main()
{
char *str1 = "ammana_babi";
char *str2 = "babi";
int offset;
if((offset = my_strspn(str1,str2)) >= strlen(str1))
printf("Can't find the different character!/n");
else
printf("%c/n",*(str1 + offset));
str1 = "abc";
str2 = "abc";
if((offset = my_strspn(str1,str2)) >= strlen(str1))
printf("Can't find the different character!/n");
else
printf("%c/n",*(str1 + offset));
system("pause");
return 0;
}
strrev()函数源码
/*
Reverses the order of characters in the string.
The terminating null character remains in place.
把字符串的所有字符的顺序颠倒过来（不包括空字符NULL）。
返回指向颠倒顺序后的字符串指针。
*/
char * my_strrev(char *str)
{
char *right = str;
char *left = str;
char ch;
while (*right) right++;
right--;
while (left < right)
{
ch = *left;
*left++ = *right;
*right-- = ch;
}
return(str);
}
/*
而我自己写的代码就略微显的有些啰里啰嗦，不简洁，
更不是很太爽快。这个问题是值得好好想一下的了。
下面就是我的垃圾代码
*/
char * my_StrReverse(char * ch)
{
char tempch,* tch;
int Len,i;
tch = ch;
Len = strlen(ch);
for(i=0;i<Len/2;i++)
{
tempch = *tch;
*tch = *(tch + Len - 2*i - 1);
*(tch+Len-2*i-1) = tempch;
tch++;
}
return ch;
}
int main()
{
char str[] ="ammana_babi";
puts(my_strrev(str));
puts(my_StrReverse(str));
system("pause");
return 0;
}
strnset()函数源码
/*
Sets the first count characters of string the character value.If the length of string is less than count, the length of string is used in place of n.
把字符串的前count个字符设置为字符val。
*/
char * my_strnset(char * str,int val,int count)
{
char *p = str;
while (count-- && *p)
*p++ = (char)val;
return(p);
}
int main()
{
char str[] ="ammana_babi";
my_strnset(str,'*',strlen(str)-4);
puts(str);
system("pause");
return 0;
}
strset()函数源码
/*
Sets all of characters in string (except the terminating '/0'character) equal to val.
把字符串的所有字符都设置为字符val。
*/
char * my_strset(char *str,int val)
{
char *p = str;
while (*str)
*str++ = (char)val;
return(p);
}
int main()
{
char str[] ="ammana_babi";
my_strset(str,'z');
puts(str);
system("pause");
return 0;
}
strupr()函数源码
/*
Force string to lower case。
将字符串转换为大写。只改变字符串中出现的小写字母，不改变其他字符。
*/
char * my_strupr(char *str)
{
char *p = str;
while (*p != '/0')
{
if(*p >= 'a' && *p <= 'z')
*p -= 0x20;
p++;
}
return str;
}
int main()
{
int i;
char str1[]= "Ammana";
char str2[] = "baBi";
char str3[] = "AMMANA";
char str4[] = "aMmAn_BabI";
puts(my_strupr(str1));
puts(my_strupr(str2));
puts(my_strupr(str3));
puts(my_strupr(str4));
system("pause");
return 0;
}
strlwr()函数源码
/*
Force string to lower case。
将字符串转换为小写。只改变字符串中出现的大写字母，不改变其他字符。
*/
char * my_strlwr(char *str)
{
char *p = str;
while (*p != '/0')
{
if(*p >= 'A' && *p <= 'Z')
*p = (*p) + 0x20;
p++;
}
return str;
}
int main()
{
int i;
char str1[]= "Ammana";
char str2[] = "baBi";
char str3[] = "AMMANA";
char str4[] = "aMmAn_BabI";
puts(my_strlwr(str1));
puts(my_strlwr(str2));
puts(my_strlwr(str3));
puts(my_strlwr(str4));
system("pause");
return 0;
}
strdup()函数源码
/*
Allocates enough storage via malloc() for a copy of the string, copies the string into the new memory, and returns a pointer to it.
复制字符串，返回指向被复制字符串的指针。所需空间由malloc()分配，且可以由free()释放。需要注意的是，在调用完这个函数后，一定要记得释放内存空间吆。
*/
#include <stdlib.h>
int my_strlen ( const char * str )
{
const char *p = str;
while( *p++ ) ;
return( (int)(p - str - 1) );
}
char * my_strcpy(char * dst, const char * src)
{
char * cp = dst;
while( *cp++ = *src++ ) ;
return( dst );
}
char * my_strdup(const char *str)
{
char *p;
if (!str)
return(NULL);
if (p = malloc(my_strlen(str) + 1))
return(my_strcpy(p,str));
return(NULL);
}
int main()
{
char *str = "ammana_babi";
char *p;
p = my_strdup("ammana_babi");
puts(p);
free(p);
system("pause");
return 0;
}
strrchr()函数源码
/*
Finds the last occurrence of ch in string. The terminating null character is used as part of the search.
查找在字符串中最后一次出现字符’ch’的位置。如果str中存在字符ch，返回出现ch的位置的指针；否则返回NULL。
*/
#include <stdlib.h>
char * my_strrchr(const char * str,int ch)
{
char *p = (char *)str;
while (*str) str++;
while (str-- != p && *str != (char)ch);
if (*str == (char)ch)
return( (char *)str );
return(NULL);
}
int main()
{
char *str = "ammana_babi";
char * p;
char ch;
ch = '9';
p = (char *)my_strrchr(str,ch);
if(p == NULL)
printf("Can't find the character %c !/n",ch);
else
printf("Find the character %c !/n",*p);
ch = 'b';
p = (char *)my_strrchr(str,ch);
if(p == NULL)
printf("Can't find the character %c !/n",ch);
else
printf("Find the character %c !/n",*p);
system("pause");
return 0;
}
strchr()函数源码
#include <stdlib.h>
/*
Searches a string for a given character, which may be the null character '/0'.
查找字符串string中首次出现字符ch的位置。如果string中存在字符ch，返回首次出现ch的位置的指针；否则返回NULL。
*/
char * my_strchr(const char *str, int ch)
{
while (*str && *str != (char)ch)
str++;
if (*str == (char)ch)
return((char *)str);
return(NULL);
}
int main()
{
char *str = "ammana_babi";
char * p;
char ch;
ch = '9';
p = (char *)my_strchr(str,ch);
if(p == NULL)
printf("Can't find the character %c !/n",ch);
else
printf("Find the character %c !/n",*p);
ch = 'b';
p = (char *)my_strchr(str,ch);
if(p == NULL)
printf("Can't find the character %c !/n",ch);
else
printf("Find the character %c !/n",*p);
system("pause");
return 0;
}
memset()函数源码
/*
Sets the first "count" bytes of the memory starting at "dst" to the character value "val".
把dst所指内存区域的前count个字节设置为val。返回指向dst的指针。
在实际应用中，我们有时候会用malloc函数来申请一些内存空间，这个内存空间有时候需要初始化，常用memset来进行初始化。
如：
int *p;
p = (int *)malloc( 0x400 * sizeof(int));
memset(p,0,0x400);
*/
void * my_memset(void *dst,int val,int count)
{
void *p = dst;
while (count--)
{
*(char *)dst = (char)val;
dst = (char *)dst + 1;
}
return p;
}
int main()
{
char str[] ="ammana_babi";
my_memset(str,'z',strlen(str));
puts(str);
system("pause");
return 0;
}
memicmp()函数源码
/*
memicmp perform a case-insensitive memory comparision.
For differences,upper case letters are mapped to lower case.Thus, "abc_" < "ABCD" since "_" < "d".
(与memcmp区别就是在比较的时候不区分大小写)比较内存区域buffer1和buffer2的前count个字节。当buffer1 < buffer2时，返回值 < 0；当buffer1 = buffer2时，返回值 0；当buffer1 > buffer2时，返回值 > 0。
*/
int my_tolower(char ch)
{
if(ch >= 'A' && ch <= 'Z')
return (ch + 0x20);
return ch;
}
int my_memicmp(const void *buffer1,const void *buffer2,int count)
{
int f = 0;
int l = 0;
while (count--)
{
if ( (*(unsigned char *)buffer1 == *(unsigned char *)buffer2) ||
((f = my_tolower( *(unsigned char *)buffer1 )) ==
(l = my_tolower( *(unsigned char *)buffer2 ))) )
{
buffer1 = (char *)buffer1 + 1;
buffer2 = (char *)buffer2 + 1;
}
else
break;
}
return ( f - l );
}
void Print(char * str1,char *str2,int t)
{
if(t > 0)
printf("/n%s Upper Than %s/n",str1,str2);
else if(t < 0)
printf("/n%s Lower Than %s/n",str1,str2);
else
printf("/n%s Equal %s/n",str1,str2);
}
int main()
{
char *str1= "ammana";
char *str2 = "babi";
char *str3 = "AMMANA";
char *str4 = "bab_";
Print(str1,str2,my_memicmp(str1,str2,4));
Print(str3,str1,my_memicmp(str3,str1,4));
Print(str4,str2,my_memicmp(str4,str2,4));
system("pause");
return 0;
}
memcmp()函数源码
/*
Compares count bytes of memory starting at buffer1 and buffer2 and find if equal or which one is first in lexical order.
比较内存区域buffer1和buffer2的前count个字节。当buffer1 < buffer2时，返回值 < 0；当buffer1 = buffer2时，返回值 0；当buffer1 > buffer2时，返回值 > 0。
*/
int my_memcmp(const void *buffer1,const void *buffer2,int count)
{
if (!count)
return(0);
while ( --count && *(char *)buffer1 == *(char *)buffer2)
{
buffer1 = (char *)buffer1 + 1;
buffer2 = (char *)buffer2 + 1;
}
return( *((unsigned char *)buffer1) - *((unsigned char *)buffer2) );
}
void Print(char * str1,char *str2,int t)
{
if(t > 0)
printf("/n%s Upper Than %s/n",str1,str2);
else if(t < 0)
printf("/n%s Lower Than %s/n",str1,str2);
else
printf("/n%s Equal %s/n",str1,str2);
}
int main()
{
char *str1= "ammana";
char *str2 = "babi";
Print(str1,str2,my_memcmp(str1,str2,3));
Print(str2,str1,my_memcmp(str2,str1,3));
Print(str2,str2,my_memcmp(str2,str2,3));
system("pause");
return 0;
}
memchr()函数源码
#include <stdlib.h>
/*
Searches at bufferfor the given character, stopping when characteris first found or cnt bytes have been searched through.
从buffer所指内存区域的前count个字节查找字符ch，当第一次遇到字符ch时停止查找。如果成功，返回指向字符ch的指针；否则返回NULL。
*/
void * my_memchr(const void * buffer,int ch,int count)
{
while ( count && (*(unsigned char *)buffer != (unsigned char)ch) )
{
buffer = (unsigned char *)buffer + 1;
count--;
}
return(count ? (void *)buffer : NULL);
}
int main()
{
char *str = "ammana_babi";
char * p;
char ch;
ch = '9';
p = (char *)my_memchr(str,ch,strlen(str)+1);
if(p == NULL)
printf("Can't find the character %c !/n",ch);
else
printf("Find the character %c !/n",*p);
ch = 'b';
p = (char *)my_memchr(str,ch,strlen(str)+1);
if(p == NULL)
printf("Can't find the character %c !/n",ch);
else
printf("Find the character %c !/n",*p);
system("pause");
return 0;
}
memccpy()函数源码
#include <stdlib.h>
/*
Copies bytes from src to dest until count bytes have been copied,or up to and including the character c, whichever comes first.
如果src前n个字节中存在’c’，返回指向字符’c’后的第一个字符的指针；否则返回NULL，src被复制。
*/
void * my_memccpy(void *dest,const void *src,int c,int count)
{
while ( count && (*((char *)(dest = (char *)dest + 1) - 1) =
*((char *)(src = (char *)src + 1) - 1)) != (char)c )
count--;
return(count ? dest : NULL);
}
/*这个函数的while条件判断写的比较长，看的眼疼，等价与以下写法：*/
void * my_memccpy01(void *dst,const void *src,int c,int count)
{
while (count)
{
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
if(*(char *)src == (char) c)
break;
src = (char *)src + 1;
count--;
}
return(count ? dst : NULL);
}
int main()
{
char a[12];
char * p;
char * str ="ammana_babi";
char ch;
ch = '9';
p = (char *)my_memccpy01(a,str,ch,strlen(str)+1);
if(p == NULL)
printf("/nCan't not find character. /n");
else
{
printf("/nFind the character! /n");
*p= '/0';
}
printf("/nThe String which has been copied is:/t");
puts(a);
printf("************************************");
ch = 'b';
p = (char *)my_memccpy01(a,str,ch,strlen(str)+1);
if(p == NULL)
printf("/nCan't not find character. /n");
else
{
printf("/nFind the character! /n");
*p = '/0';
}
printf("/nThe String which has been copied is:/t");
puts(a);
system("pause");
return 0;
}
memmove()函数源码
/*
memmove() copies a source memory buffer to a destination memory buffer.This routine recognize overlapping buffers to avoid propogation.For cases where propagation is not a problem, memcpy() can be used.
memmove()由src所指定的内存区域赋值count个字符到dst所指定的内存区域。src和dst所指内存区域可以重叠，但复制后src的内容会被更改。函数返回指向dst的指针。
*/
void * my_memmove(void * dst,const void * src,int count)
{
void * ret = dst;
if (dst <= src || (char *)dst >= ((char *)src + count))
{
while (count--)
{
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
}
else
{
dst = (char *)dst + count - 1;
src = (char *)src + count - 1;
while (count--)
{
*(char *)dst = *(char *)src;
dst = (char *)dst - 1;
src = (char *)src - 1;
}
}
return(ret);
}
int main()
{
char a[12];
puts((char *)my_memmove(a,"ammana_babi",16));
system("pause");
return 0;
}
memcpy()函数源码
/*
memcpy() copies a source memory buffer to a destination memory buffer. This routine does NOT recognize overlapping buffers, and thus can lead to propogation.For cases where propagation must be avoided, memmove() must be used.
memcpy()由src指定内存区域拷贝count个字符到dst所指定的内存区域。src和dst内存区域不能重叠，函数返回指向dst的指针。
*/
void * my_memcpy(void *dst,const void *src,int count)
{
void * ret = dst;
while (count--)
{
*(char *)dst = *(char *)src;
dst = (char *)dst + 1;
src = (char *)src + 1;
}
return(ret);
}
int main()
{
char a[12];
puts((char *)my_memcpy(a,"ammana_babi",16));
system("pause");
return 0;
}
strnicmp()函数源码
/*
Compare the two strings for lexical order. Stops the comparison when the
following occurs: (1) strings differ, (2) the end of the strings is reached,
or (3) count characters have been compared. For the purposes of the comparison,
upper case characters are converted to lower case.
字符串比较函数，比较字符串src和dst的前count个字符，但是不区分大小写，大写字母
会被转换为小写字母来进行比较。如："abc_" < "ABCD" ，因为 "_" < "d"。当源字符串
大于目标字符串的时候，返回>0；当源字符串等于目标字符串的时候，返回=0。当源字符串
小于目标字符串的时候，返回<0；
*/
int my_strnicmp(const char *dst,const char *src,int count)
{
int ch1, ch2;
do
{
if ( ((ch1 = (unsigned char)(*(dst++))) >= 'A') &&(ch1 <= 'Z') )
ch1 += 0x20;
if ( ((ch2 = (unsigned char)(*(src++))) >= 'A') &&(ch2 <= 'Z') )
ch2 += 0x20;
} while ( --count && ch1 && (ch1 == ch2) );
return (ch1 - ch2);
}
void Print(char * str1,char *str2,int t,int n)
{
char *p;
p = str1;
while(*p && (p-str1) < n) printf("%c",*p),p++;
if(t > 0)
printf("/tUpper Than/t");
else if(t < 0)
printf("/tLower Than/t");
else
printf("/tEqual/t/t");
p = str2;
while(*p && (p-str2) < n) printf("%c",*p),p++;
printf("/n");
}
#define nn 4
int main()
{
char *str1= "ammana";
char *str2 = "babi";
char *str3 = "AMMANA";
char *str4 = "bab_";
Print(str1,str2,my_strnicmp(str1,str2,nn),nn);
Print(str3,str1,my_strnicmp(str3,str1,nn),nn);
Print(str4,str2,my_strnicmp(str3,str2,nn),nn);
system("pause");
return 0;
}
stricmp()函数源码
/*
_stricmp/_strcmpi perform a case-insensitive string comparision.
For differences, upper case letters are mapped to lower case.
Thus, "abc_" < "ABCD" since "_" < "d".
字符串比较函数，比较字符串src和dst，但是不区分大小写，
大写字母会被转换为小写字母来进行比较。如："abc_" < "ABCD" ，因为 "_" < "d"。
当源字符串大于目标字符串的时候，返回>0；当源字符串等于目标字符串的时候，返回=0。
当源字符串小于目标字符串的时候，返回<0；
*/
int my_stricmp(const char *dst, const char *src)
{
int ch1, ch2;
do
{
if ( ((ch1 = (unsigned char)(*(dst++))) >= 'A') &&(ch1 <= 'Z') )
ch1 += 0x20;
if ( ((ch2 = (unsigned char)(*(src++))) >= 'A') &&(ch2 <= 'Z') )
ch2 += 0x20;
} while ( ch1 && (ch1 == ch2) );
return(ch1 - ch2);
}
void Print(char * str1,char *str2,int t)
{
if(t > 0)
printf("/n%s Upper Than %s/n",str1,str2);
else if(t < 0)
printf("/n%s Lower Than %s/n",str1,str2);
else
printf("/n%s Equal %s/n",str1,str2);
}
int main()
{
char *str1= "ammana";
char *str2 = "babi";
char *str3 = "AMMANA";
char *str4 = "bab_";
Print(str1,str2,my_stricmp(str1,str2));
Print(str3,str1,my_stricmp(str3,str1));
Print(str4,str2,my_stricmp(str4,str2));
system("pause");
return 0;
}
strncmp()函数源码
/*
Compares two strings for lexical order.
The comparison stops after: (1) a difference between the strings is found, (2) the end of the strings is reached, or (3) count characters have been compared.
比较字符串first和last的前n个字符。first > last ,>0;first = last,=0;first < last, <0 。
*/
int my_strncmp(const char *first,const char *last,int count)
{
if (!count)
return(0);
while (--count && *first && *first == *last)first++,last++;
return( *(unsigned char *)first - *(unsigned char *)last );
}
void Print(char * str1,char *str2,int t,int n)
{
char *p;
p = str1;
while(*p && (p-str1) < n) printf("%c",*p),p++;
if(t > 0)
printf("/tUpper Than/t");
else if(t < 0)
printf("/tLower Than/t");
else
printf("/tEqual/t/t");
p = str2;
while(*p && (p-str2) < n) printf("%c",*p),p++;
printf("/n");
}
#define nn 3
int main()
{
char *str1= "ammana";
char *str2 = "babi";
Print(str1,str2,my_strncmp(str1,str2,nn),nn);
Print(str2,str1,my_strncmp(str2,str1,nn),nn);
Print(str2,str2,my_strncmp(str2,str2,nn),nn);
system("pause");
return 0;
}
strcmp()函数源码
/*
STRCMP compares two strings and returns an integer
to indicate whether the first is less than the second,
the two are equal, or whether the first is greater than the second.
Comparison is done byte by byte on an UNSIGNED basis,
which is to say that Null (0) is less than any other character (1-255).
字符串比较函数，比较字符串source和dest。当源字符串大于目标字符串的时候，返回1；
当源字符串等于目标字符串的时候，返回0。当源字符串小于目标字符串的时候，返回－1；
*/
int my_strcmp(const char *source,const char *dest)
{
int ret = 0 ;
while( ! (ret = *( unsigned char *)source - *(unsigned char *)dest) && *dest)
source++, dest++;
if ( ret < 0 )
ret = -1 ;
else if ( ret > 0 )
ret = 1 ;
return(ret);
}
void Print(char * str1,char *str2,int t)
{
if(t == 0)
printf("/n%s Equal %s/n",str1,str2);
else if(t == 1)
printf("/n%s Upper Than %s/n",str1,str2);
else if(t == -1)
printf("/n%s Lower Than %s/n",str1,str2);
}
int main()
{
char *str1= "ammana";
char *str2 = "babi";
Print(str1,str2,my_strcmp(str1,str2));
Print(str2,str1,my_strcmp(str2,str1));
Print(str2,str2,my_strcmp(str2,str2));
system("pause");
return 0;
}
strncat()函数源码
/*
Appends at most count characters of the string back onto the end of front, and ALWAYS terminates with a null character.If count is greater than the length of back, the length of back is used instead.(Unlike strncpy, this routine does not pad out to count characters).
把src所指字符串的前n个字符添加到dest结尾处(覆盖dest结尾处的'/0')并添加'/0'。
src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
返回指向dest的指针。
*/
char * my_strncat(char *dest,const char *source,int count)
{
char *p = dest;
while (*p) p++;
while (count-- && (*p++ = *source++));
*p = '/0';
return(dest);
}
int main()
{
char a[20] = "ammana_";
puts(my_strncat(a,"babi",10));
system("pause");
return 0;
}
strncpy()函数源码
/*
Copies count characters from the source string to the destination.
If count is less than the length of source,NO NULL CHARACTER is put
onto the end of the copied string.If count is greater than the length
of sources, dest is padded with null characters to length count.
把src所指由NULL结束的字符串的前n个字节复制到dest所指的数组中。
如果src的前n个字节不含NULL字符，则结果不会以NULL字符结束；
如果src的长度小于n个字节，则以NULL填充dest直到复制完n个字节。
src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
返回指向dest的指针。
*/
char * my_strncpy( char * dest, const char * source, int count )
{
char *p = dest;
while (count && (*p++ = *source++)) count--;
while(count--)
*p++ = '/0';
return(dest);
}
int main()
{
char a[20];
puts(my_strncpy(a,"ammana_babi",15));
system("pause");
return 0;
}
strcat()函数源码
/*
Concatenates src onto the end of dest.
Assumes enough space in dest.
目标指针空间必须有足够的存储空间。
*/
char * my_strcat ( char * dst, const char * src )
{
char * p = dst;
while( *p ) p++;
while( *p++ = *src++ ) ;
return( dst );
}//字符串的连接
/*当然也可以用下面这种方式：*/
char * my_strcat_01(char * dst,char * src)
{
char * p = dst + strlen(dst);
strcpy(p,src);
return dst;
}
int main()
{
char str1[] = "ammana_";
char *str2 = "babi";
puts(my_strcat(str1,str2));
system("pause");
return 0;
}
strlen()函数源码
/*
得到字符串长度。（不含结束符 ‘/0’）
*/
int my_strlen(const char * str )
{
const char *p = str;
while( *p++ ) ;
return( (int)(p - str - 1) );
}
/*当然也可以采用下面的写法。*/
int my_strlen_01 ( const char * str )
{
const char *p = str;
while( *p ) p++;
return( (int)(p - str) );
}
int main()
{
char *str = "ammana_babi";
printf("%d/n",my_strlen(str));
printf("%d/n",my_strlen_01(str));
system("pause");
}
strcpy()函数源码
/*
下面是strcpy库函数的实现，因为库函数讲究的就是精练、简洁。所以没有其他的异常处理代码。主要的异常处理还是交给了函数的使用者，在调用前请确认目的和源指针是否都存在（不能为Null），请确认目标指针空间是否大于源字符串的空间。
Copies the string src into the spot specified by dest;
assumes enough room.
目标指针空间必须大于源字符串空间。
*/
char * my_strcpy(char * dst, const char * src)
{
char * cp = dst;
while( *cp++ = *src++ ) ;
return( dst );
}
int main()
{
char a[12];
puts(my_strcpy(a,"ammana_babi"));
system("pause");
return 0;
}
posted on 2018-10-30 17:55 blogernice 阅读(413) 评论(0) 编辑 收藏 举报
