三种方法模拟实现strlen

// 计数器的方法
size_t my_strlen(const char* str)
{
	assert(str);
	unsigned ret = 0;
	while (*str++)
		ret++;
	return ret;
}

//递归的方法
size_t my_strlen(const char* str)
{
	if (*str)
		return 1 + my_strlen(str + 1);
	else
		return 0;
}

//指针-指针的方法
size_t my_strlen(const char* str)
{
	const char* head = str;
	while (*str)
		str++;
	return str - head;
}

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

递归的方法中else return 0; 是必要的。否则会引发错误

模拟实现strcpy

//char* strcpy(char* destination ,const char* source);
//会将源字符串的末尾\0也拷贝进去

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

int main()
{
	char arr1[20] = "";
	char* arr2 = "Hello world";
	//my_strcpy(arr1, arr2);
	printf("%s\n", my_strcpy(arr1, arr2));
	return 0;
}

模拟实现strcat 字符串追加

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

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] = "zzzzz\0xxxxxxxx";   //是从\0处开始追加的
	char arr2[] = "abcd";
	printf("%s\n", my_strcat(arr1, arr2));
	return 0;
}

从目标字符串的\0处开始追加，直到源字符串的\0处停止

模拟实现strcmp? 字符串比较函数

//字符串比较函数 int strcmp(const char*s1,const char*s2)
int my_strcmp(const char* s1, const char* s2)
{
	assert(s1 && s2);
	while (*s1 == *s2)
	{
		if (s1 == '\0')
			return 0;
		s1++;
		s2++;
	}
	return *s1 - *s2;
}

int main()
{
	char arr1[] = "abcdefgg";
	char arr2[] = "abcdee";
	printf("%d\n", my_strcmp(arr1, arr2));
	return 0;
}

模拟实现strncpy? 给定字符个数的字符串拷贝函数

//char* strncpy(char* destnation,const char* source,size_t num)

char* my_strncpy(char* dest, const char* src, size_t num)
{
	assert(dest && src);
	char* ret = dest;
	size_t i = 0;
	for (i = 0; i < num; i++)
	{
		if (!*(src + i))
			break;
		*(dest + i) = *(src + i);
	}
	for (; i < num; i++)
	{
		*(dest + i) = '\0';
	}
	return ret;
}

int main()
{
	char arr1[20] = "xxxxxxxxxxxxxx";
	char arr2[] = "abcdef";
	my_strncpy(arr1, arr2, 8);
	printf("%s\n", arr1);
	return 0;
}

若拷贝的字符个数多余源字符串的字符个数，则补\0至数量足够

如果拷贝的字符个数少于源字符串个数，拷贝指定个数之后，不会自动补\0?

模拟实现strncat? 给定字符个数的字符串追加函数?

//char* strncat(char* destination,const char* source,size_t num)
char* my_strncat(char* dest, const char* src, size_t num)
{
	//多追加,也是到达\0停止  如果少追加,自动补\0
	assert(dest && src);
	char* ret = dest;
	while (*dest)
		dest++;
	int flag = 0;
	size_t i = 0;
	for (i = 0; i < num; i++)
	{
		*(dest + i) = *(src + i);
		if (!*(src + i))
		{
			flag = 1;
			break;
		}
	}
	if (!flag)
		*(dest + i) = '\0';
	return ret;
}


int main()
{
	char arr1[20] = "xxxxxx\0xxxxxxxxxx";
	char arr2[] = "abcdef";
	printf("%s\n", my_strncat(arr1, arr2, 3));   //即使是多追加，也是到达\0就停止
	return 0;
}

?如果追加的字符个数多于源字符串，则追加至\0自动停止，如果少于源字符串，则自动补\0?

模拟实现strncmp? 给定字符个数的字符串比较函数?

//int strncmp(const char* str1, const char* str2, size_t num);
int my_strncmp(const char* str1, const char* str2, size_t num)
{
	assert(str1 && str2);
	size_t i = 0;
	for (i = 0; i < num; i++)
	{
		if (*(str1 + i) != *(str2 + i))
			return *(str1 + i) - *(str2 + i);
		if ('\0' == *(str1 + i))
			return 0;
	}
	return 0;
}
int main()
{
	char arr1[] = "abcdee";
	char arr2[] = "abcdee";
	printf("%d\n", my_strncmp(arr1, arr2, 8));
	return 0;
}

模拟实现strstr? 检验是否是子字符串的函数?

char* my_strstr(const char* dest, const char* src)
{
	assert(dest && src);
	while (*dest)
	{
		const char* lhs = dest;
		const char* rhs = src;
		while (*lhs == *rhs)
		{
			if (*(rhs + 1) == '\0')
				return dest;
			lhs++;
			rhs++;
		}
		dest++;
	}
	return NULL;
}


int main()
{
	char arr1[20] = "aaabcdef";
	char arr2[] = "abce";
	char * ret = my_strstr(arr1, arr2);
	printf("%s\n", ret);
	return 0;
}