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

• 求字符串长度(strlen)
• 长度不受限制的字符串函数(strcpy,strcat,strcmp)
• 长度受限制的字符串函数介绍(strncpy,strncat,strncmp)
• 字符串查找(strstr,strtok)
• 错误信息报告(strerror)
• 字符操作
• 内存操作函数(memcpy,memmove,memset,memcmp)

函数介绍+部分模拟实现

strlen

int my_strlen(const char * str)
{
	int count = 0;
	while(*str)
	{
		count++;
		str++;
	}
	return count;
}
1
2
3
4
5
6
7
8
9
10

strcpy,strcat,strcmp

char *my_strcpy(char *dest, const char*src)
{
	char *ret = dest;
	assert(dest != NULL);
	assert(src != NULL);
	while((*dest++ = *src++))
	{
		;
	}
	return ret;
}
1
2
3
4
5
6
7
8
9
10
11

char *my_strcat(char *dest, const char*src)
{
	char *ret = dest;
	assert(dest != NULL);
	assert(src != NULL);
	while(*dest)
	{
		dest++;
	}
	while((*dest++ = *src++))
	{
		;
	}
	return ret;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

int my_strcmp (const char * src, const char * dst)
{
    int ret = 0 ;
	assert(src != NULL);
 	assert(dest != NULL);
    while( ! (ret = *(unsigned char *)src - *(unsigned char *)dst) && *dst)
        ++src, ++dst;
    if ( ret < 0 )
        ret = -1 ;
    else if ( ret > 0 )
        ret = 1 ;
    return( ret );
}
1
2
3
4
5
6
7
8
9
10
11
12
13

strncpy,strncat,strncmp

char * strncpy ( char * destination, const char * source, size_t num );
拷贝num个字符从源字符串到目标空间
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个
char * strncat ( char * destination, const char * source, size_t num );
int strncmp ( const char * str1, const char * str2, size_t num );
1
2
3
4
5

strstr,strtok

char *  strstr (const char * str1, const char * str2)
{
    char *cp = (char *) str1;
    char *s1, *s2;
    if ( !*str2 )
      	return((char *)str1);
    while (*cp)
   	{
        s1 = cp;
        s2 = (char *) str2;
        while ( *s1 && *s2 && !(*s1-*s2) )
            s1++, s2++;
        if (!*s2)
            return(cp);
        cp++;
   	}
    return(NULL);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

char * strtok ( char * str, const char * sep );
1

sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记
strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记
如果字符串中不存在更多的标记，则返回 NULL 指针

#include 
#include 
int main ()
{
 	char str[] ="- This, a sample string.";
 	char * pch;
 	printf ("Splitting string \"%s\" into tokens:\n",str);
 	pch = strtok (str," ,.-");
 	while (pch != NULL)
	{
  		printf ("%s\n",pch);
  		pch = strtok (NULL, " ,.-");
	}
 		return 0;
}
#include 
int main()
{
 	char *p = "zhangpengwei@bitedu.tech";
	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("%s\n", str);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

strerror

char * strerror ( int errnum );
#include 
#include 
#include //必须包含的头文件
int main ()
{
 	FILE * pFile;
 	pFile = fopen ("unexist.ent","r");
 	if (pFile == NULL)
  		printf ("Error opening file unexist.ent: %s\n",strerror(errno));
  //errno: Last error number
 	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

字符分类函数

函数 如果他的参数符合下列条件就返回真
iscntrl 任何控制字符
isspace 空白字符：空格‘ ’，换页‘\f’，换行’\n’，回车‘\r’，制表符’\t’或者垂直制表符’\v’
isdigit 十进制数字 0~9
isxdigit 十六进制数字，包括所有十进制数字，小写字母a ~ f，大写字母A~F
islower 小写字母a~z
isupper 大写字母A~Z
isalpha 字母a ~ z或A~Z
isalnum 字母或者数字，a ~ z,A ~ Z,0~9
ispunct 标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph 任何图形字符
isprint 任何可打印字符，包括图形字符和空白字符

内存函数

memcpy,memmove,memset,memcmp

void * memcpy ( void * dst, const void * src, size_t count)
{
    void * ret = dst;
	assert(dst);
 	assert(src);
    while (count--) {
        *(char *)dst = *(char *)src;
        dst = (char *)dst + 1;
        src = (char *)src + 1;
   }
    return(ret);
}
1
2
3
4
5
6
7
8
9
10
11
12

void * memmove ( void * dst, const void * src, size_t count)
{
    void * ret = dst;
    if (dst <= src || (char *)dst >= ((char *)src + count)) {
        /*
        * copy from lower addresses to higher addresses
        */
        while (count--) {
            *(char *)dst = *(char *)src;
            dst = (char *)dst + 1;
            src = (char *)src + 1;
       }
   }
    else {
        /*
        * Overlapping Buffers
        * copy from higher addresses to lower addresses
        */
        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);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28