C语言拯救者（模拟实现字符串函数和内存函数--11）

目录

C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。

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

1.1 strlen

1.2 三种方式模拟实现strlen库函数

1.3 strcpy 字符串拷贝

1.4 模拟实现strcpy

strcpy函数返回的是目标空间的起始地址

strcpy函数的返回类型的设置是为了实现链式访问

1.5 strcat 字符串追加

1.6 模拟实现strcat

1.7 strcmp 比较字符串

1.8 模拟实现strcmp

2  长度受限制的字符串函数

2.1 strncpy

2.2 strncat

2.3 strncmp

2.4 strstr  在一个字符串中找另一个字符串

2.5 模拟实现strstr

2.6 strtok

2.7 strerror  perror  返回错误码，所对应的错误信息

2.8 字符分类函数

3. 内存操作函数

3.1 memcpy 内存空间数据拷贝

3.2 模拟实现memcpy

 在同一块内存拷贝，目标和源头数据空间有交叉，我们应该用memmove

3.3 memmove  可以实现重叠内存拷贝

3.4  模拟实现memmove

3.5 memcpy  内存字节对应比较

3.6  memset  以字节为单位进行内存设置

---

C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。

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

1.1 strlen

size_t strlen ( const char * str );//函数原型，注意函数的返回值为size_t

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

char arr[] = { 'a', 'b', 'c', 'd', 'e', 'f' };//无法用strlen求字符串长度

char arr[10] = { 'a', 'b', 'c', 'd', 'e', 'f' };//限定长度，可以求

 下面结果是什么？

 if ((int)strlen("abc") - (int)strlen("qwerty") > 0)
	{
		printf(">\n");
	}
	else
	{
		printf("<=\n");
	}

答案：>,两个无符号数相减结果是正数

---

1.2 三种方式模拟实现strlen库函数

通常写法

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

size_t my_strlen(const char* str)
{
	int count = 0;//统计字符的个数
    assert(str);
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
 
 
int main()
{
	char arr[] = "abcd";
	//char* str = arr;
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

递归

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

//my_strlen("abcdef")
//1+my_strlen("bcdef")
//1+1+my_strlen("cdef")
//1+1+1+ my_strlen("def")
//1+1+1+1+ my_strlen("ef")
//1 + 1 + 1 + 1 +1+my_strlen("f")
//1 + 1 + 1 + 1 + 1 + 1+ my_strlen("")
//1 + 1 + 1 + 1 + 1 + 1 + 0 = 6
 
size_t my_strlen(const char* str)
{
    assert(str);
	if (*str != '\0')
		return 1 + my_strlen(str+1);
	else
		return 0;
}
 
int main()
{
	char arr[] = "abcd";
	//char* str = arr;
	int len = my_strlen(arr);
	printf("%d\n", len);
	return 0;
}

指针-指针方法

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


size_t my_strlen(const char* arr,int sz)//指针-指针
{
    assert(arr);
    char* right = arr + sz - 1;
    return right - arr;
}
 
int main()
{
    char arr[] = "hello";
    int sz = sizeof(arr) / sizeof(arr[0]);
    int len=my_strlen(arr,sz);
    printf("%d", len);
    return 0;
}

---

1.3 strcpy 字符串拷贝

字符串拷贝，把源字符串拷贝放到目标空间字符串中，其中需要注意的事项

1.源字符串必须以 '\0' 结束。

char arr1[20] = {0};
char arr2[] = {'a','b','c'};//程序崩溃，没有\0

2.会将源字符串中的 '\0' 拷贝到目标空间。

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

int main()
{
	
	char arr1[] = "XXXXXXXXXXXX";//arr1指向的是常量字符串，常量是不可修改的
	char arr2[] = "abcdef";
	strcpy(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

3.目标空间必须足够大，以确保能存放源字符串。

strcpy不管空间够不够，只要你敢写它就敢放，哪怕程序崩溃

char arr1[4] = "x";
char arr2[] = "abcdef";
strcpy(arr1, arr2);//程序崩溃

4.目标空间必须可变。

char* arr1 = "qwertyuiop";//arr1指向的是常量字符串，常量是不可修改的
char arr2[] = "abcdef";
strcpy(arr1, arr2);//程序崩溃

1.4 模拟实现strcpy

strcpy函数返回的是目标空间的起始地址

strcpy函数的返回类型的设置是为了实现链式访问

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

int main()
{
	char arr1[20] = { 0 };
	char* arr2 = "hello world";

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

---

1.5 strcat 字符串追加

int main()
{
	char arr1[10] =  "hello " ;
	char* arr2 = "world";

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

注意事项：

1.源字符串必须以 '\0' 结束。 从\0位置开始追加

int main()
{
	char arr1[20] =  "hello\0XXXXX" ;
	char arr2[] = "world";

	printf("%s\n", strcat(ar