C语言字符串内存函数的实现

一.求字符串长度

①.strlen

size_t strlen ( const char * str );
字符串已经 '\0' 作为结束标志，strlen函数返回的是在字符串中 
'\0' 前面出现的字符个数（不包含 '\0' )。
参数指向的字符串必须要以 '\0' 结束。
注意函数的返回值为size_t，是无符号的（ 易错 ）

例题：
int main(){//返回值为size_t，是无符号的
	const char*str1 = "abcdef";
	const char*str2 = "bbb";
	if (strlen(str2) - strlen(str1)>0)
	{
		printf("str2>str1\n");//正确结果
	}
	else
	{
		printf("srt1>str2\n");
	}
	system("pause");
	return 0;
}

模拟实现

size_t My_strlen(char * str){
	assert(STR!=NULL);
	unsigned count = 0;
	while (*str++){
		count++;
	}
	return count;
}

二.长度不受限制的字符串函数

①.strcpy

char* strcpy(char * destination, const char * source );
源字符串必须以 '\0' 结束。
会将源字符串中的 '\0' 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。

模拟实现

char* My_strcpy(char * destination, const char * source){
	assert(destination!=NULL);
	assert(source!=NULL);
	char*flag = destination;
	while ((*flag++ = *source++)){
	}
	*flag = '\0';
	return destination;
}

②.strcat

char * strcat ( char * destination, const char * source );
源字符串必须以 '\0' 结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改

char * My_strcat(char * destination, const char * source){
	assert(destination!=NULL);
	assert(source!=NULL);
	char*flag = destination;
	while (*flag){
		flag++;
	}
	while (*flag++ = *source++){
	}
	*flag = '\0';
	return destination;
}

③.strcmp

int strcmp ( const char * str1, const char * str2 );
标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字

模拟实现

int my_strcmp(const char* arr1, const char* arr2) { 
    assert(arr1 != NULL && arr2 != NULL);
    while (*arr1 != '\0' && *arr2 != '\0') {
        if (*arr1 > *arr2) {
            return 1;
        } else if (*arr1 < *arr2) {
            return -1;
        } else {
            arr1++;
            arr2++;
        }
    }
    if (*arr1 == '\0' && *arr2 != '\0') {
        return -1;
    } else if (*arr2 == '\0' && *arr1 != '\0') {
        return 1;
    } else
        return 0;
}

三.长度受限制的字符串函数介绍

①.strncpy

char * strncpy ( char * destination, const char * source, size_t num );
拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

模拟实现

char * My_strncpy(char * destination, const char * source, size_t num){
	assert(destination!=NULL);
	assert(source!=NULL);
	char*str = destination;
	size_t len = strlen(source);
	if (len>num){
		while (num){
			*str++ = *source++;
			num--;
		}
	}else{
		while (*str++ = *source++){}
	}
	*str = '\0';
	return destination;
}

②.strncat

char * strncpy ( char * destination, const char * source, size_t num );

模拟实现

char * My_strncat(char * destination, const char * source, size_t num){
	assert(destination!=NULL);
	assert(source!=NULL);
	char *str = destination;
	size_t len = strlen(source);
	while (*str){
		str++;
	}
	if (len > num){
		while (num-- ){
			*str++ = *source++;
		}
	}
	else{
		while (*str++ = *source++){}
	}
	*str = '\0';
	return destination;
}

③.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!=NULL);
	assert(str2!=NULL);
	char *arr1 = str1;
	char *arr2 = str2;
	while (*arr1 != '\0' && *arr2 != '\0'&&num) {
		if (*arr1 > *arr2) {
			return 1;
		}
		else if (*arr1 < *arr2) {
			return -1;
		}
		else {
			arr1++;
			arr2++;
			num--;
		}
	}
	if (*arr1 == '\0' && *arr2 != '\0') {
		return -1;
	}
	else if (*arr2 == '\0' && *arr1 != '\0') {
		return 1;
	}
	else
		return 0;
}

四.字符串查找

①.strstr

char *My_strstr(const char *str1, const char *str2);
Returns a pointer to the first occurrence of str2 in str1,
or a null pointer if str2 is not part of str1.

模拟实现

char *My_strstr(const char *str1, const char *str2){
	assert(str1 != NULL);
	assert(str2 != NULL);
	if (*str2 == '\0'){
		return NULL;
	}
	char *s_str1 = (char*)str1;
	char *s_str2 = (char*)str2;
	char *flag = NULL;//保存每次初始循环时str1的地址
	while (*s_str1){
		flag = s_str1;
		s_str2 = (char*)str2;
		while (*s_str1&&*s_str2 && (*s_str1 == *s_str2)){
			s_str1++;
			s_str2++;
		}
		if (*s_str2 == '\0'){
			return flag;
		}
		s_str1++;
	}
	return NULL;
}

②.strtok

char * strtok ( char * str, const char * sep );
sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改
变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
如果字符串中不存在更多的标记，则返回 NULL 指针。

③.strerror

char * strerror ( int errnum );
返回错误码，所对应的错误信息

五.内存操作函数

memcpy

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

模拟实现

void * My_memcpy(void * destination, const void * source, size_t num){
	assert(destination != NULL);
	assert(source != NULL);
	void * str1 = destination;
	void *str2 = source;
	while (num)
	{
		*(char*)str1 = *(char*)str2;
		(char*)str1 = (char*)str1 + 1;
		(char*)str2 = (char*)str2 + 1;
		num--;
	}
	return destination;
}

memmove

void * memmove ( void * destination, const void * source, size_t num );
和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。

void *my_memmove(void *dst, const void *src, size_t num)
{
	assert(dst != NULL);
	assert(src != NULL);
	const char*src_p = (char*)src;
	char *dst_p = (char*)dst;
	if (dst_p > src_p && dst_p < src_p + num){
		src_p = src_p + num - 1;
		dst_p = dst_p + num - 1;
		while (num > 0){
			*dst_p = *src_p;
			dst_p--;
			src_p--;
	    	num--;
		}
	}
	else{
		while (num > 0){
			*dst_p = *src_p;
			dst_p++;
			src_p++;
			num--;
		}
	}
	return dst;
}

memset

void *memset(void *s,int ch,size_t n);
某一块内存中的内容全部设置为指定的值（以字节为单位）

模拟实现

void *My_memset(void *s, int ch, size_t n){
	assert(s != NULL);
	void *str = s;
	while (n--){
		*(char*)str = ch;
		str = (char*)str + 1;
	}	
}

memcmp

int memcmp ( const void * ptr1,const void * ptr2,size_t num );
比较从ptr1和ptr2指针开始的num个字节