字符函数和字符串函数

目录

               函数介绍

1.1 strlen——求字符串的长度

1.2 strlen函数的模拟实现（三种方式）

1.2.1计数器方法实现

1.2.2函数递归

1.2.3指数相减

2.1 strcpy——字符串的拷贝

2.2 strcpy函数的模拟实现

3.1 strcat——字符串的追加

3.2 strcat函数的模拟实现

4.1 strcmp——比较字符串的大小

4.2 strcmp函数的模拟实现

5.1 strstr——相当于找子集

5.2 strstr函数的模拟实现 

6.1 memcpy

6.2 模拟实现memcpy

7.1 memmove

7.2 memmove函数的模拟实现

---

函数介绍

1.1 strlen——求字符串的长度

size_t strlen( const char *string );

 注意：

①strlen函数返回的是在字符中'\0'前面出现的字符个数（不包括'\0'）

②参数指向的字符串要以'\0'结束

③注意函数的返回值是size_t，是无符号的

1.2 strlen函数的模拟实现（三种方式）

1.2.1计数器方法实现

size_t my_strlen1(char* str)
{
	assert(str);
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

1.2.2函数递归

size_t my_strlen2(char* str)
{
    assert(str);
    if(*str == '\0')
        return 0;
    return 1+my_strlen2(str+1);
}

1.2.3指数相减

size_t my_strlen3(const char* str)
{
    assert(str);
    char* p=str;
    while(*p != '\0')
    {
        p++;
    }
    return p-str;
}

主函数 

int main()
{
	char ch[] = "abcdef";
	int len = my_strlen3(ch);
	printf("%d", len);
	return 0;
}

2.1 strcpy——字符串的拷贝

char *strcpy( char *strDestination, const char *strSource );

注意：

①源字符串必须以'\0'结束

②会将源字符串的中的'\0'拷贝到目标空间

③目标空间必须足够大，以确保能存放源字符串

④目标空间必须可变 

2.2 strcpy函数的模拟实现

char* my_strcpy(char* dest, const char* src)
{
    assert(dest && src);
    char* ret = dest;
    while(*dest++ = *src++)
    {
        ;
    }
    return ret;
}

//主函数
int main()
{
	char arr1[50] = { 0 };
	char arr2[] = "abcdefg";
	my_strcpy(arr1, arr2);
	printf("%s", arr1);
	return 0;
}

3.1 strcat——字符串的追加

char * strcat ( char * destination, const char * source );

 注意：

①源字符串必须以'\0'结束

②目标空间必须足够大，能容纳下源字符串的内容

③目标空间必须可修改

3.2 strcat函数的模拟实现

char* my_strcat(char* dest, const char* src)
{
    assert(dest && src);
    char* ret=dest;
    while(*dest)
    {
        dest++;
    }
    while(*dest++ = *src++)
    {
        ;
    }
    return ret;
}

//主函数
int main()
{
	char arr1[20] = "hello";
	char arr2[20] = "world";
	my_strcat(arr1, arr2);
	printf("%s", arr1);
	return 0;
}

4.1 strcmp——比较字符串的大小

int strcmp ( const char * str1, const char * str2 );

标准规定：

①第一个字符串大于第二个字符串，则返回大于0的数字

② 第一个字符串等于第二个字符串，则返回0 

③第一个字符串小于第二个字符串，则返回小于0的数字

4.2 strcmp函数的模拟实现

int my_strcmp(const char* dest,const char* src)
{
    assert(dest && src);
    while(*dest == *src)
    {
        if(*dest == '\0')
            return 0;
        dest++;
        src++;
    }
    return *dest-*ret;
}

//主函数
int main()
{
	char arr1[20] = "abcdef";
	char arr2[20] = "abc";
	int ret = my_strcmp(arr1, arr2);
	if (ret > 0)
		printf(">");
	else if (ret < 0)
		printf("<");
	else
		printf("==");
	return 0;
}

5.1 strstr——相当于找子集

char *strstr( const char *string, const char *strCharSet );

5.2 strstr函数的模拟实现 

char* my_strstr(const char* str1, const char* str2)
{
    assert(str1 && str2);
    const char* s1 = str1;
    const char* s2 = str2;
    char* cur=s1;
    while(*cur)
    {
        s1 = cur;
        s2 = str2;
        while(*s1 && *s2 && (*s1==*s2))
        {
            s1++;
            s2++;
        }
        cur++;
        if(*s2 == '\0')
            return (char*)cur;
    }
    return NULL;

}

//主函数
int main()
{
	char arr1[] = "abcabcdef";
	char arr2[] = "abc";
	char* ret = my_strstr(arr1, arr2);
	if (NULL == ret)
		printf("找不到这个子串");
	else
		printf("%s", ret);
	return 0;
}

6.1 memcpy

void * memcpy ( void * destination, const void * source, size_t num );

标准规定：

①函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置

②这个函数在遇到'\0'的时候并不会停下来

③如果source和destination有任何的重叠，复制的结果都是未定义的

6.2 模拟实现memcpy

 

void* my_memcpy(void* dest, const void* src, size_t count)
{
	assert(dest && src);
	char* ret = (char*)dest;
	while (count--)
	{
		*(char*)dest  =  *(char*)src;//强制类型转换
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[5] = { 0 };
	my_memcpy(arr2, arr1, 20);
	int sz = sizeof(arr2) / sizeof(arr2[0]);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

7.1 memmove

void * memmove ( void * destination, const void * source, size_t num );

标准规定：

①和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的

②如果源空间和目标空间出现重叠，就得使用memmove函数处理 

7.2 memmove函数的模拟实现

void* my_memmove(void* dest, const void* src, size_t count)
{
	assert(dest && src);
	char* ret = (char*)dest;
		if (dest < src)
		{
			while (count--)
			{
				*(char*)dest = *(char*)src;
				dest = (char*)dest + 1;
				src = (char*)src + 1;
			}
		}
		else
		{
			while (count--)
				*((char*)dest + count) = *((char*)src + count);
		}
		return ret;
	}
int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr1+2, arr1, 20);
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}