C语言集合（字符函数和字符串函数实现）

注意：‘\0’代表空字符，其ASCII值为0. 0的ASCII值为48.

一、strlen()

1. 字符串以‘\0’作为结束标志，strlen()返回‘\0’之前的字符个数，不包含‘\0’。
2. 常量字符串存储在静态区，用const 修饰代表指针指向的内容不可以修改。
3. 返回值是无符号的。
4. 模拟实现：

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

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

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

int main()
{
	char* arr = "abcde";
	printf("%zd\n", my_strlen1(arr));
	printf("%zd\n", my_strlen2(arr));
	printf("%zd\n", my_strlen3(arr));
	return 0;
}

二、strcpy()

1. 源字符必须以‘\0’作为结束标志。
2. ‘\0’也会被拷贝到目标空间。
3. 必须确保目标空间足够大。

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

int main()
{
	char* arr1 = "abcde";
	char arr2[10] = "xxxxxxx";
	printf("%s\n", my_strcpy(arr2,arr1));
	return 0;
}

三、strcat()

1. 目标空间要足够大并且可以修改。
2. 目标空间和源空间都要有‘\0’。
3. 源字符串中的‘\0’也会被拷贝，自己给自己追加时会出错，因为‘\0’会被第一个字符覆盖，就找不到‘\0’了。

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

int main()
{
	char* arr1 = "abcde";
	char arr2[20] = "xxxxxxx";
	printf("%s\n", my_strcat(arr2,arr1));
	return 0;
}

四、strcmp()

1. 比较的不是长度，是各个位置对应的字符，实际比较的是ASCII码值。
2. 大于则返回大于0的数字，小于则返回小于0的数字，相等则返回0。

int my_strcmp(const char* str1, const char* str2)
{
    assert(str1&&str2);
	while (*(str1) && *(str2))
	{
		if (*str1 != *str2)
		{
			return (int)(*str1-*str2);
		}
		str1++;
		str2++;
	}
	if (*(str1) == '\0' && *(str2) == '\0')
	{
		return 0;
	}
	else
	{
		return (int)(*str1 - *str2);
	}
}

int main()
{
	char* str1 = "abcdefg";
	char* str2 = "abcdef";
	printf("%d", my_strcmp(str1, str2));

	return 0;
}

五、strncpy()

1. 从原字符串拷贝num个字符到目标空间，不拷贝‘\0’。
2. 如果源字符长度小于num，则拷贝完源字符串，在后面追加‘\0’，直到num个。

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

int main()
{
	char str1[20] = "abcxxxxxxxxxxx";
	char* str2 = "abcdef";
	my_strncpy(str1, str2, 8);
	printf("%s",str1);

	return 0;
}

六、strncat()

1. 找到目标空间的‘\0’，从‘\0’ 开始追加num个字符，最后加上‘\0’。
2. 如果num个数超过源空间字符个数，则会只追加一个‘\0’。

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

int main()
{
	char str1[20];
	char str2[20];
	strcpy(str1, "To be ");
	strcpy(str2, "or not");
	my_strncat(str1, str2, 2);
	puts(str1);

	return 0;
}

七、strncmp()

1. 比较到出现另一个字符或者一个字符串结束或者num个字符全部比较完。

int main()
{
	char str[][6] = { "abcd","adef","abbc" };
	for (int n = 0; n < 3; n++)
	{
		if (strncmp(str[n], "abxx", 2)==0)
		{
			puts(str[n]);
		}
	}
	return 0;
}

八、strstr()

1. 寻找字符串2在字符串1里第一次出现的地址，如果没有，则返回NULL，如果寻找的是空字符串，则返回目标空间地址。

char* my_strstr(const char* str1, const char* str2)
{
	assert(str1&&str2);
	char* cp = (char*)str1;
	char* s1 = (char*)str1, *s2 = (char*)str2;

	if (*str2 == '\0')
	{
		return (char*)str1;
	}

	while (*cp)
	{
		s1 = cp;
		s2 = (char*)str2;

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

int main()
{
	char* s1 = "abcde";
	char* s2 = "cd";
	puts(my_strstr(s1, s2));

	return 0;
}

九、strtok()

1. 第一个参数是要切割字符串的地址，第二个参数是切割字符串的地址。
2. strtok()会找到下一个标记，并将其用\0结尾，返回指向这个标记的指针。注意：会改变原来的字符串，所以最好拷贝原来的字符串。
3. 第一个参数不为NULL，返回str中第一个标记的位置。
4. 第一个参数为NULL，则返回标记的位置的下一个位置。
5. 如果不存在更多标记，则返回NULL。

int main()
{
	char* p = "zhangwei@163.com";
	char arr[30];
	strcpy(arr, p);
	const char* sep = "@.";
	char* str = NULL;

	for (str = strtok(arr, sep); str != NULL; str = strtok(NULL, sep))
	{
		puts(str);
	}
	return 0;
}

十、strerror()和perror()

1. 需要包含头文件<erron.h>.
2. errno变量存储错误信息，注意输入参数的形式。

int main()
{
	FILE* pfile;
	pfile = fopen("abc.text", "r");
	if (pfile == NULL)
	{
		perror("Error opening file", &errno);
		printf("Error opening file: %s", strerror(errno));
	}
	return 0;
}

十、memcpy()

1. memcpy从source的位置开始，向后复制num个字符到destination的位置，两个部分不能有重叠。
2. 遇到‘\0’不会停止。

struct person
{
	char name[20];
	int age;
}person1 = {"xiaohong",10};

void* my_memcpy(void* dest, const void* sour, size_t num)
{
	assert(dest&&sour);
	void* ret = dest;

	while (num--)
	{
		*(char*)dest = *(char*)sour;
		dest = (char*)dest + 1;
		sour = (char*)sour + 1;
	}
	return ret;
}

int main()
{
	char arr1[30] = "abcdef";
	char arr2[30] = "ghijk";
	struct person person2 = {"xiaoming",3};
	/*char* str = (char*)my_memcpy(arr1, arr2, 2);*/
	/*char* str = (char*)memcpy(arr1,arr2,2);*/
	char* str = (char*)my_memcpy(&person1, &person2, sizeof(person1));
	puts(person1.name);

	return 0;
}

十一、memset()

十二、memmove()

1. 如果源空间和目标空间重合，就可以用memmove()。

void* my_memmov(void* dest, const void* sour, size_t num)
{
	void* ret = dest;

	if (dest <= sour || ((char*)sour + num) <= (char*)dest)
	{
		while (num--)
		{
			*(char*)dest = *(char*)sour;
			dest = (char*)dest + 1;
			sour = (char*)sour + 1;
		}
	}
	else
	{
		dest = (char*)dest + num - 1;
		sour = (char*)sour + num - 1;
		while (num--)
		{
			*(char*)dest = *(char*)sour;
			dest = (char*)dest - 1;
			sour = (char*)sour - 1;
		}
	}
	return ret;
}

int main()
{
	char arr1[30] = "abcdef";
	char* arr = my_memmov(arr1, arr1 + 2, 3);
	puts(arr);

	return 0;
}