字符串函数与内存函数讲解

---

---

前言

---

一、字符串函数

1.求字符串长度

strlen

1、功能：求字符串长度
2、使用：
（1）介绍：

说明：
a.返回类型是size_t，也就是无符号整形（只有正数没有负数）
b.参数是char* 类型；加入const修饰是为了防止对str中存放的内容进行修改
c.字符串已经 ‘\0’ 作为结束标志，strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )

（2）头文件：
（3）举例：
  a.

int main() {
	char arr1[] = "abcdefg";
	size_t len1 = strlen(arr1);
	return 0;
}
1
2
3
4
5

解析：
(1)strlen函数做需要的参数是char* 类型，所以创建了一个char类型的数组
(2在不是sizeof(数组名)与 &数组名 的情况下，数组名代表数组首元素的地址，首元素地址的类型是char*
(3)strlen 函数的返回值是size_t类型，也就是无符号的整形，所以我们设置一个相应类型的值来接收它

 b.

int main() {
	char* arr2 = "abcdef";
	size_t len2 = strlen(arr2);
	size_t len3 = strlen("abcdef");
	printf("%d %d\n",len2,len3);
	return 0;
}
1
2
3
4
5
6
7

结果：

解析：
这里的len2和len3的最后结果其实是一致的，因为len3中的字符串其实传输的也是首元素的地址，属于char*类型，与len2中的传输的值是一样的
 c.

int main() {
	char* arr3 = "abc\0def";
	char* arr4 = "abcde\0f";
	size_t len3 = strlen(arr3);
	size_t len4 = strlen(arr4);
	printf("%d %d\n", len3, len4);
	return 0;
}
1
2
3
4
5
6
7
8

结果：
解析：
strlen函数返回的是在字符串中 ‘\0’ 前面出现的字符个数（不包含 ‘\0’ )

（4）注意事项：
 a.参数指向的字符串必须要以 ‘\0’ 结束。
 b.注意函数的返回值为size_t，是无符号的

3、模拟实现：
 方法一：

size_t my_strlen(const char* str) {
	//计录字符串长度
	size_t count = 0;
	//当*str='\0'是停止
	while (*str) {
		count++;
		str++;
	}
	return count;
}

int main() {
	char arr1[] = "abcdefg";
	size_t len1 = my_strlen(arr1);
	printf("%d\n",len1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#emsp;方法二

//递归实现
size_t my_strlen(const char* str) {
	if (*str == '\0') {
		return 0;
	}
	//这里不能使用后置++，因为它是先使用后++
	return 1 + my_strlen(str+1);
}

int main() {
	char arr1[] = "abcdefg";
	size_t len1 = my_strlen(arr1);
	printf("%d\n", len1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

 方法三：

//指针实现
size_t my_strlen(const char* str) {
	//创建一个临时变量来接收str
	char* p = str;
	//对临时变量进行操作更加安全
	while (*p != '\0') {
		p++;
	}
	//字符串中有几个字符，p就会往后移动几位
	return p - str;
}

int main() {
	char arr1[] = "abcdefg";
	size_t len1 = my_strlen(arr1);
	printf("%d\n", len1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

(1)strcpy

1、功能：字符串拷贝
2、使用：
（1）介绍：

说明：
a.参数有两个，都是char* 类型：拷贝源与目的地
b.返回值是char* 类型，返回目的地的地址
c.头文件：

(2)注意：
a.源字符串必须以 ‘\0’ 结束,，因为它是拷贝结束的标志，没有的话会一直拷贝，会越界访问
b.会将源字符串中的 ‘\0’ 拷贝到目标空间。
c.目标空间必须足够大，以确保能存放源字符串。
d.目标空间必须可变。

（3）举例：
a.

int main() {
	char arr1[20];
	char arr2[] = "abcdef";
	printf("%s\n",arr1);
	strcpy(arr1,arr2);
	printf("%s\n",arr1);
	return 0;
}
1
2
3
4
5
6
7
8

结果：
解析：
未对arr1进行初始化化，所以刚开始赋予的是随机值；在strcpy函数后，为其拷贝了值

3、模拟实现

char* my_strcpy(char* dest,const char* src) {
	//设置一个指针来存储目的地的起始地址
	char* ret = dest;
	//设置断言，防止对空指针解引用
	assert(src && dest);
	//对dst赋值，当赋值'\0'后不满足条件，退出循环
	while (*dest++ = *src++) {
		;
	}
	return ret;
}

int main() {
	char arr1[20];
	char arr2[] = "abcdef";
	my_strcpy(arr1,arr2);
	printf("%s\n",arr1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

(2)strcat

1、功能：字符串追加
2、使用：
（1）介绍：

说明：
a.参数有两个，char*类型：源和目的地
b.返回的是目的地的起始地址
c.本函数是寻找目的地中的’\0’，从’\0’处开始追加源中的字符，并将原来的’\0’替换，将自己的’\0’拷贝过去

（2）注意：
a.必须保证目标空间要足够大
b.目标空间中必须有\0（保证能找到目标空间的末尾）
c.原字符串也得有\0，在拷贝时将\0也拷过去
d.目标空间必须可以修改

（3）举例：

int main() {
	char arr1[20] = "abcd";
	char arr2[] = "efgh";
	strcat(arr1,arr2);
	printf("%s\n",arr1);
	return 0;
}
1
2
3
4
5
6
7

结果：

3、模拟实现

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

int main() {
	char arr1[20] = "abcd";
	char arr2[] = "efgh";
	my_strcat(arr1,arr2);
	printf("%s\n",arr1);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

(3)strcmp

1、功能：字符串比较
2、使用：
（1）介绍：


说明：
a.参数有两个，是比较的两个数组
b.当字符串1>字符串2时，返回一个>0的数
 当字符串1=字符串2，返回一个<0的数
 当字符串1<字符串2时，返回一个<0的数
c.两字符串比较的其实是每个字符的ASCII码值

(2)注意：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字

（3）举例：

int main() {
	char arr1[] = "abbc";
	char arr2[] = "abcd";
	int ret = strcmp(arr1,arr2);
	printf("%d\n",ret);
	return 0;
}
1
2
3
4
5
6
7

3、模拟实现

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

int main() {
	char arr1[] = "abbc";
	char arr2[] = "abcd";
	int ret = my_strcmp(arr1,arr2);
	printf("%d\n",ret);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

(1)strncpy

1、功能：限制数量的字符串拷贝
2、使用：
（1）介绍：

说明：多了一个数量限制，其余的与函数strcpy一致
（2）注意：
a.当源字符串中的字符数没有达到参数的数量时，会在目的地中自动补’\0’，直到达到限定数量
b.目的地的大小应该比限定数量大，否则就会非法访问
（3）举例：
a.

int main() {
	char arr1[10];
	char arr2[] = "abcdefg";
	strncpy(arr1,arr2,10);
	printf("%s\n",arr1);
	return 0;
}
1
2
3
4
5
6
7

结果：

(2)strncat

1、功能：限制数量的字符串追加
2、使用：
（1）介绍：

说明：多了一个数量限制，其余与函数strcat一致
（2）注意：
与函数strcat一致
（3）举例：
a.

int main() {
	char arr1[20] = "bcc";
	char arr2[] = "abcdefg";
	strncat(arr1, arr2, 10);
	printf("%s\n", arr1);
	return 0;
}
1
2
3
4
5
6
7

结果：

(3)strncmp

1、功能：限制数量的字符串比较
2、使用：
（1）介绍：

（3）举例：
a.

int main() {
	char arr1[] = "abc";
	char arr2[] = "abcdefg";
	int ret = strncmp(arr1, arr2, 4);
	printf("%d\n", ret);
	return 0;
}
1
2
3
4
5
6
7

结果：

4.字符串查找

(1)strstr

1、功能：字符串查找
2、使用：
（1）介绍：

说明：
a.有两个参数都是char类型，在str1中查找是否有str2中的字符串
b.返回值是char 类型，返回的是str1中查找的字符串的首地址
（2）注意：
a.如果字符串中有两个查找的字符串，会默认返回第一个找到的字符串的首地址
b.查找不到时会返回Null值
c.查找过程中碰到’\0’就会停止

（3）举例：
a.

int main() {
	char arr1[] = "abccbcccf";
	char arr2[] = "bccc";
	char * ret = strstr(arr1, arr2);
	printf("%s\n", ret);
	return 0;
}
1
2
3
4
5
6
7

结果：
b.

int main() {
	char arr1[] = "abccbcccf";
	char arr2[] = "g";
	char * ret = strstr(arr1, arr2);
	printf("%s\n", ret);
	return 0;
}
1
2
3
4
5
6
7

结果：

c.

int main() {
	char arr1[] = "abc\0bcccf";
	char arr2[] = "bccc";
	char * ret = strstr(arr1, arr2);
	printf("%s\n", ret);
	return 0;
}
1
2
3
4
5
6
7

结果：

3、模拟实现

const char* my_strstr(const char* str1,const char* str2) {
	//创建一个临时变量作为查找元素时的定位符
	const char* p = str1;
	const char* s1;
	const char* s2;
	assert(str1 && str2);
	while (*p) {
		//每次都从p处开始比较
		s1 = p;
		//如果没有完全找到，就要重头开始找
		s2 = str2;
		//不相等或者任意一方为'\0'时停止
		while ((*s1 && *s2 && *s1 == *s2)) {
			s1++;
			s2++;
		}
		//判断是否全部找到
		if (*s2 == '\0') {
			return p;
		}
		p++;
	}
	return NULL;
}

int main() {
	char arr1[] = "abccbcccf";
	char arr2[] = "bc";
	char * ret = my_strstr(arr1, arr2);
	printf("%s\n", ret);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

(2)strtok

1、功能：字符串分隔
2、使用：
（1）介绍：

说明：
a.有两个参数，都是char类型，第一个是等待分割的字符串，第二个是分隔符
b.返回值是charl类型，返回分隔后的字符串的首地址

（2）注意：
a.每次调用只会对字符串进行一次分隔
b.函数strtok会记住上一次分隔的结束位置，从那个位置开始进行下一次分割，但此次不能为它传输新的字符串指针，只能传输分隔符

（3）举例：
a.

int main() {
	char arr1[] = "abc@de.fg@h";
	char* d = "@.";
	char* ret = strtok(arr1, d);
	printf("%s\n", ret);
	return 0;
}
1
2
3
4
5
6
7

结果：

b.

int main() {
	char arr1[] = "abc@de.fg@h";
	char* d = "@.";
	for (char* ret = strtok(arr1, d); ret != NULL; ret = strtok(NULL, d)) {
		printf("%s\n",ret);
	}
	return 0;
}
1
2
3
4
5
6
7
8

结果:

5.错误信息报告

(1)strerror

1、功能：错误信息反馈
2、使用：
（1）介绍：

a.头文件
b.参数是int类型，是错误所对应的错误码
c.返回值是char* 类型，返回错误码，所对应的错误信息

（2）注意：
a.当程序产生错误时，会自动将错误码放入错误信息errno中
（3）例子：
a.

int main() {
	for (int i = 0; i <= 10; i++) {
		printf("%d %s\n",i,strerror(i));
	}

	return 0;
}
1
2
3
4
5
6
7

结果：

b.

//打开文件
int main() {
	//打开成功返回一个FILE* 类型的指针，打开失败返回一个NULL指针
	FILE* pfile = fopen("add.txt","r");
	//产生错误的时候，会自动的将错误码放入错误信息errno中
	if (pfile == NULL) {
		printf("打开失败的原因是:%s\n",strerror(errno));
	}

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

结果：

(2)perror

1、功能：错误信息打印
2、使用：
（1）介绍：

说明：此处参数可传可不传，属于你的自定义信息，类似与printf中你输入的文字，它会默认将程序中的错误信息打印出来，你可以自由加一些自定义信息

(2)注意：
a.打印规则，先打印自定义信息，然后 “ ：空格”，再打印错误信息

（3）实例：

int main() {
	FILE* pfile = fopen("add.txt", "r");
	if (pfile == NULL) {
		perror("打开失败的原因是");
	}

	return 0;
}
1
2
3
4
5
6
7
8

结果：

二、内存函数

内存函数与字符串函数最重要的区别是：内存函数适用于所有类型

1.memcpy

1、功能：内存拷贝
2、使用：
（1）介绍：

说明：
a.头文件：
b.参数有三个，前两个是void* 类型的，是拷贝源于目的地；最后一个是拷贝的字节数

（2）注意：
a.传输的数字是字节数，而不是元素个数
b.函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
c.这个函数在遇到 ‘\0’ 的时候并不会停下来。
d.如果source和destination有任何的重叠，复制的结果都是未定义的。
（3）示例：
a.

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

结果：

3、模拟实现

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

int main() {
	int arr1[10] = { 0 };
	int arr2[] = { 1,2,3,4,5 };
	my_memcpy(arr1,arr2,20);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

2.memmove

1、功能：内存移动
2、使用：
（1）介绍：

说明：
和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。
（2）注意：
a.在模拟实现中，起码要有两种情况

（3）示例：
a.

int main() {
	char arr1[] = "abcdefgh";
	memmove(arr1+2,arr1+3,4);
	printf("%s\n",arr1);

	return 0;
}
1
2
3
4
5
6
7

结果：

3、模拟实现：

void* my_memmove(void* dest,const void* src,size_t num) {
	void* ret = dest;
	assert(dest && src);
	//小于时，从后往前拷贝
	if (src < dest) {
		while (num--) {
			*((char*)dest+ num) = *((char*)src+num);
		}
	}
	//其他情况，从前往后拷贝
	else{
		while (num--) {
			*(char*)dest = *(char*)src;
			src = (char*)src + 1;
			dest = (char*)dest + 1;
		}
	}
	return ret;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.memset

1、功能：内存设置
2、使用：
（1）介绍：

说明：以字节为单位设置值
（2）注意：
a.因为单位是字节，所以最适用于字符类型的数组

（3）示例：
a.
int main() {
char arr1[] = “hello world”;
memset(arr1+6, ‘a’, 5);
printf(“%s\n”,arr1);
}
结果：

4.memcmp

1、功能：内存比较
2、使用：
（1）介绍：

说明：比较两内存空间的前num个字节的内容

（2）注意：
第一个内存块大于第二个内存块，则返回大于0的数字
第一个内存块等于第二个内存块，则返回0
第一个内存块小于第二个内存块，则返回小于0的数字

（3）示例：
a.

int main() {
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 1,3,3,4,5 };
	int ret1 = memcmp(arr1,arr2,4);
	//小端存储
	int ret2 = memcmp(arr1,arr2,5);
	printf("%d %d\n",ret1,ret2);
}
1
2
3
4
5
6
7
8

结果：