模拟实现strlen、strstr、memcpy和 memmove

---

模拟实现strlen

定义：

size_t strlen ( const char * str );

字符串已经有 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数(不包 含 ‘\0’ )。

代码实现：

#include <stdio.h>
#include <assert.h>

// 1. 计数器方式
size_t my_strlen(const char * str){
	assert(str);	// //检测str是否为空指针
	
	int count = 0;
    while(*str++){	// 运算符顺序：先解引用再++
    	++count;
    }
    return count;
}

// 2. 不能创建临时变量计数器
size_t my_strlen_1(const char * str){
	assert(str);
	
    if(*str == '\0') return 0;
    else return 1+my_strlen_1(++str);
}

// 3. 指针-指针的方式
size_t my_strlen_2(const char * str){
	assert(str);
	
    const char * p = str;
    while(*p){
        p++;
    }
    return p - str;
}

int main(){
    char arr[] = "abcdefg";
	size_t ret = my_strlen(arr);
	printf("%zu\n", ret);   // %zu用来输出size_t类型
    return 0;
}

模拟实现strstr

定义：

char * strstr ( const char * str1, const char * str2 );

返回一个指向 str1 中第一次出现的 str2 的指针，如果 str2 不是 str1 的一部分，则返回一个空指针。

代码实现：

#include <stdio.h>
#include <assert.h>

char *my_strstr(const char* str1, const char* str2){
	// 检测str1;str2是否为空指针
	assert(str1 && str2);

	char * cp = (char *)str1;
    char * s1;
    char * s2;

    if(*str2 == '\0') return NULL;
    while(*cp){
        s1 = cp;
        s2 = (char *)str2;
        while(*s1 && *s2 && *s1 == *s2){
            s1++;
            s2++;
        }
        if(*s2 == '\0') return cp;
        cp++;
    }
    return NULL;
}

int main(){
	char arr1[] = "abcbcdef";
	char arr2[20] = "bcde";

	printf("%s\n", my_strstr(arr1, arr2));
	return 0;
}

模拟实现memcpy

定义：

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

函数 memcpy 从 source 的位置开始向后复制 num 个字节的数据到 destination 的内存位置。 这个函数在遇到 ‘\0’ 的时候并不会停下来。 如果 source 和 destination 有任何的重叠，复制的结果都是未定义的。

代码实现：

#include <stdio.h>
#include <assert.h>

// 模拟实现 memcpy
void * my_memcpy(void * dst, const void * src, size_t count){
	// 检测str1;str2是否为空指针
	assert(dst);
	assert(src);
	
	void * ret = dst;
	// 不存在内存重叠
	while (count--) {
		*(char *)dst = *(char *)src;
		dst = (char *)dst + 1;//void类型，不能 ++
		src = (char *)src + 1;//void类型，不能 ++
	}
	return ret;
}

int main(){
	char arr1[10] = "abcbcdef";
	char arr2[10] = "bcde";

	printf("%s\n", my_memcpy(arr1+4, arr1, 3));
	return 0;
}

提问：strcpy和memcpy都是标准C库函数，它们有哪些区别？

1. 复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符串、整型、结构体、类等。
2. 复制的方法不同。strcpy不需要指定长度，它遇到被复制字符串的结束符"\0”才结束，所以容易溢出。memcpy则是根据第3个参数决定复制的长度。
3. 用途不同。通常在复制字符串时用strcpy，而需要复制其它类型的数据是用memcpy。

模拟实现memmove(可重叠的memcpy)

定义：

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

memmove和memcpy的差别就是memmove函数处理的源内存块和目标内存块是 可以重叠的。 如果源空间和目标空间出现重叠，就得使用memmove函数处理。

代码实现：

#include <stdio.h>
#include <assert.h>

// 模拟实现 memmove
void * my_memmove(void * dst, const void * src, size_t count){
	// 检测str1;str2是否为空指针
	assert(dst);
	assert(src);

	void * ret = dst;
	if ((char *)dst <= (char *)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 {
		// (重叠）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;
}

int main(){
	char arr1[10] = "abcbcdef";
	char arr2[10] = "bcde";

	printf("%s\n", my_memmove(arr1 + 4, arr1, 5));
	return 0;
}

---

1024 庆祝一下，拿个小勋章