C语言关于字符串库函数的模拟实现

测字符串长度 :> strlen的模拟实现

size_t strlen ( const char * str );

• 参数指向的字符串必须要以 ‘\0’ 结束。
• 函数的返回值为size_t 是 unsigned int，是无符号的。

#include <stdio.h>

size_t my_strlen(const char* p)
{
  const char* sp = p;
	  while (*(++p))
	{
	;
    }
    return p - sp;
    }

int main()
{
	char* p = "hello bit";
	int ret = my_strlen(p);
	printf("%d", ret);
	return 0;
}

将源字符串拷贝到目标数组中(非字符串常量) :> strcpy的模拟实现

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

• 源字符串以 ‘\0’ 结束
• 源字符串中的 ‘\0’ 拷贝到目标空间
• 目标空间必须足够大，以确保能存放源字符串

#include<stdio.h>

char* my_strcpy(char* dest, const char* sor)
{
	char* newstr = dest;
	while (*dest++ = *sor++)
	{
		;
	}
	return newstr;
}

int main()
{
	char arr[10] = { 0 };
	const char* p = "hello bit";
	my_strcpy(arr, p);
	printf("%s",arr);
	return 0;
}

将源字符串的副本追加到目标字符串 :> strcat的模拟实现

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

• 源字符串以 ‘\0’ 结束
• 目标空间必须有足够的大，能容纳下源字符串的内容

char* my_strcat(char* destination, const char* source)
{
	char* cur = destination;
	while (*(++cur))
	{
		;
	}
	while (*cur++ = *source++)
	{
		;
	}
	return destination;
}

int main()
{
	char p1[30] = "hello ";
	char* p2 = "bit";

    my_strcat(p1, p2);
	printf("%s", p1);
	return 0;
}

比较每个字符串第一个不同的字符(ASCII码值的比较) :> strcmp的模拟实现

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

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

int my_strcmp(const char* p1, const char* p2)
{
    assert(p1 && p2);
	while (*(++p1) == *(++p2))
	{
		;
	}
	return *p1 - *p2;
}

int main()
{
	char* p1 = "abcd";
	char* p2 = "abce";

	int ret = my_strcmp(p1, p2);
	printf("%d", ret);

	return 0;
}

查找目标字符串中是否与源字符串相同,若相同则返回指向与源字符串相同目标字符串的地址,否则返回NULL :> strstr的模拟实现

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

• str1为目标字符串
• str2为源字符串

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

int main()
{
	char str1[] = "abcdef";
	char str2[] = "b";
	char* str3 = my_strstr(str1,str2);
	//printf("%s", str3);
	if (str3)
	{
		printf("找到了");
	}
	else
	{
		printf("没找到");
	}

	return 0;
}

内存操作符 :> memcpy的模拟实现

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

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

void* my_memcpy(void* dest, const void* src, size_t num)
{
  assert(dest);
  assert(src);
	void* buf = dest;
  while (num--)
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return buf;
}

int main()
{
	int arr1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
	int arr2[5] = { 0 };

	my_memcpy(arr2, arr1, 20);
	for (int i = 0; i < 5; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

内存操作符 :> memmove 的模拟实现

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

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

void* my_memmove(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest);
	assert(src);
	
	if (dest < src)
	{
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		while (num--)
		{
			*((char*)dest+num) = *((char*)src+num);

		}
		return ret;
	}
}

int main()
{
	int arr1[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int arr2[5] = { 0 };

	my_memmove(arr2,arr1,20);
	return 0;
}