C语言字符和字符串函数(2)

大家好，我今天继续来给大家分享C语言中的字符和字符串函数。

目录

**
1.字符分类函数
2.memcpy
3.memmove
4.memcmp**

1.字符分类函数

islower判断字母小写函数

int main()
{
	char ch = 'w';
	if (islower(ch))
	{
		printf("小写\n");
	}
	else
	{
		printf("非小写\n");
	}
	printf("%d ", islower(ch));

	return 0;
}

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

我们这个函数只要是小写的字母就会返回一个非0的数字，而不是小写的字母就会返回0。

isxdigit函数

这个是用来判断十六进制，十进制，还有大小写字母的函数，如果是的话就会返回非0值，不是的话就会返回0。

int main()
{
	int ret = isxdigit('q');
	printf("%d\n", ret);

	return 0;
}
1
2
3
4
5
6
7

toupper和tolower函数，小写转大写，大写转小写

int main()
{
	int ret = toupper('a');
	printf("%c\n", ret);//A
	ret = tolower(ret);
	printf("%c\n", ret);//'a'

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

这里再看到一个实例：

int main()
{
	char arr[] = "Test String.\n";
	char* p = arr;
	while (*p)
	{
		if (isupper(*p))
		{
			*p = tolower(*p);
		}
		p++;
	}
	printf("%s", arr);
	return 0;
}

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

这里我们用到了指针，指针里存放的是数组的地址，当我们判断*p是不是大写时，如果是就转小写，不是就进行下个字符的操作。学到了这里大家应该都明白了这些函数的使用原理。

2.memcpy函数

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

第一个参量是我们要复制的数据存储的空间，第二个参数是我们要复制的数据所在的空间，第三个参数是我们要复制的字节个数。

我们对这个函数进行模拟实现，看到代码：

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

int main()
{
	int arr1[10] = { 0 };
	int arr2[] = { 1,2,3,4,5 };
	//把arr2中的前5个整数的数据，拷贝放在arr1中
	my_memcpy(arr1, arr2, 20);
	int i = 0;
	for(i=0;i<10;i++)
	printf("%d ", arr1[i]);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这里我们要实现将数组arr2中的五个整数拷贝到数组arr1中，所以我们第一个参数指针储存的就是arr1的地址，第二个参数指针储存的就是arr2的地址，我们这里要拷贝五个整数，一个整数是四个字节，所以我们这里要拷贝五个整数就是20个字节。在这里我们要注意的是我们的指针是void型的，我们在拷贝时是一个一个字节进行拷贝，所以我们要对指针进行强制转换，char 型的指针是一个字节，所以我们给它解引用赋值给指针test就行，因为我们要拷贝数组arr2，所以数组arr2的数据是不会变化的，所以我们就可以对它用const进行修饰，我们要记得给它进行断言防止两个指针是空指针。

那我们如果要对一个数组本身进行拷贝呢，如图：

我们要将arr数组的前五个整数拷贝到数组arr的3到7位置，我们怎么做呢，那么我们传参的量是不是不一样呢？在这里我们可以很清楚的看到我们要拷贝的数组和我们拷贝到储存的数组中间是有一个重叠部分的，那我们这样会不会运行成功呢？

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

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	            //1 2 1 2 3 4 5 8 9 10
	my_memcpy(arr+2, arr, 20);

	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~7的位置拷贝成1,2，3,4，5，但是这里是1,2，1,2，1，这里是为什么，因为我们要拷贝的地方有重叠部分，我们把1拷贝到3的位置的时候已经改变了它在内存中的数据，也就是说这个位置不再是3，而是1，所以把3的位置拷贝到5的位置的时候就是1，后面的也是这样，那我们接下来可以通过下一个函数解决这个问题。

3.memmove函数

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。

我们看到这个函数的参数类型其实和第一个函数差不多，但是这个函数和第一个有个不同的特点，就是这个函数专门用来拷贝有重叠区域的数据。

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	            //1 2 1 2 3 4 5 8 9 10
	//my_memcpy(arr+2, arr, 20);
	memmove(arr+2, arr, 20);
	//memcpy(arr + 2, arr, 20);
	

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12

我们看到我们使用这个函数，直接就可以实现我们要实现的目的了。

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	            //1 2 1 2 3 4 5 8 9 10
	//my_memcpy(arr+2, arr, 20);
	//memmove(arr+2, arr, 20);
	memcpy(arr + 2, arr, 20);
	

	return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12

但是我们在这里发现memcpy函数在vs2022的环境中也可以对它进行处理，也能够完成拷贝的任务，我们规定的是memmove来实现有重叠部分的拷贝工作，但是我们的memcpy在vs2022的环境中也是满分。

那么我们想要模拟实现memmove函数该怎么实现呢？

我们要想将1 ~5拷贝到3 ~7的位置，中间又有重叠的部分，我们又该怎么样去做呢？这个时候我们就该考虑拷贝
的顺序了，到底是从前往后呢还是从后往前呢？如果我们要被拷贝的src在拷贝的dest前面，那么我们就采取从后往前拷贝的顺序，如果我们拷贝的dest在被拷贝的src前面，那么我们就采取从前往后的顺序拷贝。那么我们在这里就要找到一个分界线，前面用前往或者后往前的顺序，后面的则相反，这样的话我们就可以避开重叠部分实现拷贝。我们找到3为一个分界线从前往后，那么我们实现1和2的拷贝之后就是从前往后的顺序拷贝，我们之前拷贝了1到3的位置，所以在这个时候我们就得采取从后往前的顺序拷贝了。

【看到代码】：

void* my_memmove(void* dest, const void* src, size_t sz)
{
	assert(dest && src);
	void* ret = dest;
	if (dest < src)
	{
		//前->后
		int i = 0;
		for (i = 0; i < sz; i++)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//后->前
		while (sz--)
		{
			*((char*)dest+sz) = *((char*)src + sz);
		}
	}
	return ret;
}

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	my_memmove(arr+2, arr, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}

	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
33
34
35
36
37
38

我们看到代码运行的结果发现我们运行的成功了。

在这里我们在学习一个以字节为单位进行拷贝的函数。memset函数。

//memset 是设置内存的
//是以字节为单位设置内存的
int main()
{
	char arr[] = "hello world";
	memset(arr+6, 'x', 3);
	printf("%s\n", arr);

	//int arr[10] = { 0 };
	//memset(arr, 0, 40);

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

我们看到我们这里很简单的就将arr里的三个字符换成三个‘x’了。那如果是整型的数组我们是否可以完成拷贝呢？

//memset 是设置内存的
//是以字节为单位设置内存的
int main()
{
	/*char arr[] = "hello world";
	memset(arr+6, 'x', 3);
	printf("%s\n", arr);*/

	int arr[10] = { 0 };
	memset(arr, 0, 40);

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

如果是0的话还是可以拷贝的，如果是别的数的话不能执行了。

4.memcmp函数

我们这个函数也是一个字节一个字节比较大小，如果参数1大于我们的参数2就会返回一个大于0的值，等于就返回0，小于就返回小于0的值。

接下来我们看到实例：

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7 };
	//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00
	//
	int arr2[] = { 1,2,3,0x11223304 };
	//01 00 00 00 02 00 00 00 03 00 00 00 04 33 22 11
	int ret = memcmp(arr1, arr2, 13);
	printf("%d\n", ret);

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

我们这里有一个陷阱就是我们这里放的是一个十六进制的数，我们对arr1和arr2进行比较13个字节的大小可能很多小伙伴就会有疑惑了吧，但是请注意我们只比较13个字节的大小，而前13个字节的大小是相等的，所以我们这里返回的就是0。

学习的美好时光总是短暂的，我们今天就学到这里吧，下次再见，谢谢大家。