|
/*
*
*从src所指向的对象复制n个字符到dest所指向的对象中。
*如果复制过程中遇到了字符c则停止复制，返回指针指向dest中
*字符c的下一个位置；否则返回NULL。
*
*/
void *memccpy (void *dest_in, const void *src_in, char c, size_t n)
{
int counter = 0;
char *dest = (char *)dest_in;
char *src = (char *)src_in;
char *src_for_count = (char *)src_in;
int src_len = 0;
while(*src_for_count)
src_len++;
if( (dest == NULL) || (src == NULL) || (n == 0) || (n > src_len))
{
printf("Invalid Parameters!\n");
return ;
}
while(*src && (counter <= n))
{
if(*src == c)
break;
*dest++ = *src++;
counter ++;
}
dest++;
*dest = '\0';
return (void *)dest;
}
/*
*
*从src所指向的对象复制n个字符到dest所指向的对象中。
*返回指针为dest的值。
*
*/
void *memcpy (void *dest_in, const void *src_in, size_t n)
{
char *dest = (char *)dest_in;
char *src = (char *)src_in;
char *src_for_count = (char *)src_in;
int src_len = 0;
while(*src_for_count)
src_len++;
if((dest == NULL) || (src == NULL) || (n > src_len))
{
printf("Invalid Parameters!\n");
return ;
}
while(n--)
*dest++ = *src++;
return (void *)dest;
}
/*
*
*从src所指向的对象复制n个字符到dest所指向的对象中。
*返回指针为dest的值。与memcpy不同的是，memmove考虑
*到了内存重叠现象。
*/
void *memmove(void *dest_in, const void *src_in, size_t n)
{
char *dest = (char *)dest_in;
char *src = (char *)src_in;
if( (dest == NULL) || (src == NULL) )
{
printf("Invalid Parameters!\n");
return ;
}
/**发生内存重叠**/
if((dest + n > src) && (dest < src))
{
while(n--)
*dest++ = *src++;
}
else if((src + n > dest) && (src < dest))
{
src += (n - 1);
dest += (n - 1);
while(n--)
*(--dest) = *(--src);
}
else /**无内存重叠发生**/
{
while(n--)
*dest++ = *src++;
}
return (void *)dest;
}
/*
*
*在s所指向的对象的前n个字符中搜索字符c。
*如果搜索到，返回指针指向字符c第一次出现的位置；
*否则返回NULL。
*
*/
void *memchr (const void *str_in, char c, size_t n)
{
char *str = (char *)str_in;
int str_len =0;
while(*str++)
str_len++;
str -= str_len;
while(n--)
{
if(*str++ == c)
return (void *)str;
}
return NULL;
}
/*
*
*比较s1所指向的对象和s2所指向的对象的前n个字符。
*返回值是s1与s2第一个不同的字符差值。
*
*/
int memcmp (const void *str1_in, const void *str2_in, size_t n)
{
char *str_first = (char *)str1_in;
char *str_second = (char *)str2_in;
int result = 0;
int counter = 0;
int str_len_first = 0;
int str_len_second = 0;
if((str_first == NULL) || (str_second == NULL) || (n <= 0))
{
printf("Invalid paramters!\n");
return ;
}
while(*str_first++)
str_len_first++;
while(*str_second++)
str_len_second++;
if(n > str_len_first || n > str_len_second)
{
printf("Invalid paramters!\n");
return ;
}
str_first -= str_len_first;
str_second -= str_len_second;
while(counter <= n)
{
if(*str_first++ == *str_second++)
{
counter++;
continue;
}
else
break;
}
result = *str_first - *str_second;
return result;
}
/*
*
*比较s1所指向的对象和s2所指向的对象的前n个字符，忽略大小写。
*返回值是s1与s2第一个不同的字符差值。
*
*/
int memicmp (const void *s1, const void *s2, size_t n)
{
}
/*
*
*设置s所指向的对象的前n个字符为字符c。返回指针为s的值。
*
*/
void *memset (void *str_in, char c, size_t n)
{
char *str = (char *)str_in;
int str_len = 0;
if(str == NULL || n < 0)
{
printf("Invalid parameters!\n");
return ;
}
while(*str)
str_len++;
if(n > str_len)
{
printf("Invalid parameters!\n");
return ;
}
while(n--)
*str++ = c;
return (void *)str;
}
/*
*
*复制字符串src到dest中。返回指针为dest + len(src)的值。
*
*/
char *stpcpy (char *dest, const char *src)
{
if(dest == NULL || src == NULL)
{
printf("Invalid parameters!\n");
return ;
}
while(*dest++ = *src++);
return dest;
}
/*
*
*复制字符串src到dest中。返回指针为dest的值。
*
*/
char *strcpy (char *dest, const char *src)
{
if(dest == NULL || src == NULL)
{
printf("Invalid parameters!\n");
return ;
}
char *dest_begin = dest;
while(*dest++ = *src++);
return dest_begin;
}
/*
*
*将字符串src添加到dest尾部。返回指针为dest的值。
*
*/
char *strcat (char *dest, const char *src)
{
if(dest == NULL || src == NULL)
{
printf("Invalid parameters!\n");
return ;
}
char *dest_begin = dest;
while(*dest++);
dest--;
while(*dest++ = *src++);
return dest_begin;
}
/*
*
*在字符串s中搜索字符c。
*如果搜索到，返回指针指向字符c第一次出现的位置；
*否则返回NULL。
*
*/
char *strchr (const char *str_in, char c)
{
if(str_in == NULL)
{
printf("Invalid parameters!\n");
return ;
}
char *str = str_in;
while(*str)
{
if(*str++ == c)
break;
}
return str;
}
/*
*
*比较字符串s1和字符串s2。返回值是s1与s2第一个不同的字符差值。
*
*/
int strcmp (const char *str_first, const char *str_second)
{
int result = 0;
if(str_first == NULL || str_second == NULL)
{
printf("Invalid parameters!\n");
return ;
}
while(*str_first++ == *str_second++);
str_first--;
str_second--;
result = *str_first - *str_second;
return result;
}
/*
*
*比较字符串s1和字符串s2，忽略大小写。
*返回值是s1与s2第一个不同的字符差值。
*
*/
int stricmp (const char *str_first, const char *str_second)
{
int result = 0;
if(str_first == NULL || str_second == NULL)
{
printf("Invalid parameters!\n");
return ;
}
while(*str_first && *str_second)
{
if((*str_first == *str_second)
||((*str_first + ('a' - 'A')) == *str_second)
||(*str_first == (*str_second + ('a' - 'A'))))
{
str_first++;
str_second++;
continue;
}
}
result = *str_first - *str_second;
return result;
}
/*
*
*返回值是字符串s1的完全由不包含在字符串s2中的字符组成的初始串长度。
*
*/
size_t strcspn (const char *s1, const char *s2)
{
}
/*
*
*返回值是字符串s1的完全由包含在字符串s2中的字符组成的初始串长度。
*
*/
size_t strspn (const char *s1, const char *s2)
{
}
/*
*
*得到一个字符串s的复制。返回指针指向复制后的字符串的首地址。
*
*/
char *strdup (const char *s)
{
}
/*
*
*返回值是字符串s的长度。不包括结束符'\0'。
*
*/
size_t strlen (const char *s)
{
int length = 0 ;
if(s == NULL)
{
printf("Invalid parameter\n");
return ;
}
/*if( ; ((*s++) != '\0'); length++);*/
while(*s++)
length++;
return length;
}
/*
*
*将字符串s全部转换成小写。返回指针为s的值。
*
*/
char *strlwr (char *s)
{
if(s == NULL)
{
printf("Invalid parameter!\n");
return ;
}
do
{
/*0x41 == A && 0x5A == Z*/
if((*s >= 0x41) && (*s <= 0x5A))
*s += ('a' - 'A');
}while(*s++);
}
/*
*
*将字符串s全部转换成大写。返回指针为s的值。
*
*/
char *strupr (char *s)
{
if(s == NULL)
{
printf("Invalid parameter!\n");
return ;
}
do
{
/*0x61 == A && 0x7A == Z*/
if((*s >= 0x61) && (*s <= 0x7A))
*s -= ('a' - 'A');
}while(*s++);
}
/*
*
*将字符串src添加到dest尾部，最多添加max_len个字符。返回指针为dest的值。
*
*/
char *strncat (char *dest, const char *src, size_t max_len)
{
if(src == NULL || dest == NULL)
{
printf("Invalid parameter!\n");
return ;
}
int src_len = 0;
int counter = 0;
while(*src++)
src_len++;
src -= src_len;
if(max_len > src_len)
{
printf("Invalid parame\n");
return ;
}
while(*dest++);
while(counter <= max_len && *src)
{
*dest++ = *src++;
counter++;
}
return dest;
}
/*
*
*比较字符串s1和字符串s2，最多比较max_len个字符。
*返回值是s1与s2第一个不同的字符差值。
*
*/
int strncmp (const char *str_first, const char *str_second, int max_len)
{
int result = 0;
if(str_first == NULL || str_second == NULL)
{
printf("Invalid parameters!\n");
return ;
}
int counter = 0;
int second_len = 0;
while(*str_second++)
second_len++;
str_second -= second_len;
if(max_len > second_len)
{
printf("Invalid parameters!\n");
return ;
}
while(counter <= max_len)
{
if(*str_first++ == *str_second++)
{
counter++;
continue;
}
else
break;
}
str_first--;
str_second--;
result = *str_first - *str_second;
return result;
}
/*
*
*复制字符串src到dest中，最多复制max_len个字符。返回指针为dest的值。
*
*/
char *strncpy (char *dest, const char *src, int max_len)
{
if(dest == NULL || src == NULL)
{
printf("Invalid parameters!\n");
return ;
}
int counter = 0;
int src_len =0;
while(*src++)
src_len++;
src -= src_len;
if(max_len > src_len)
{
printf("Invalid parameters!\n");
return ;
}
char *dest_begin = dest;
while(counter <= max_len)
{
*dest++ = *src++;
counter++;
}
return dest_begin;
}
/*
*
*比较字符串s1和字符串s2，忽略大小写，最多比较max_len个字符。
*返回值是s1与s2第个不同的字符差值。
*
*/
int strnicmp(const char *s1, const char *s2, size_t max_len)
{
}
/*
*
*设置字符串s中的前n个字符全为字符c。返回指针为s的值。
*
*/
char *strnset (char *s, int ch, size_t n)
{
}
/*
*
*设置字符串s中的字符全为字符c。返回指针为s的值。
*
*/
char *strset (char *s, int ch)
{
}
/*
*
*返回指针指向字符串s1中字符串s2的任意字符第一次出现的位置；
*如果未出现返回NULL。
*
*/
char *strpbrk (const char *s1, const char *s2)
{
}
/*
*
*在字符串s中搜索字符c。
*如果搜索到，返回指针指向字符c最后一次出现的位置；
*否则返回NULL。
*
*/
char *strrchr (const char *s, int c)
{
}
/*
*
*将字符串全部翻转，返回指针指向翻转后的字符串。
*
*/
char *strrev (char *str_in)
{
}
/*
*
*在字符串s1中搜索字符串s2。
*如果搜索到，返回指针指向字符串s2第一次出现的位置；
*否则返回NULL。
*
*/
char *strstr (const char *s1, const char *s2)
{
}
/*
*
*用字符串s2中的字符做分隔符将字符串s1分割。
*返回指针指向分割后的字符串。
*第一次调用后需用NULLL替代s1作为第一个参数。
*
*/
char *strtok (char *s1, const char *s2)
{
}
|
