笔记20-2（C语言进阶 内存函数）

目录

注：

字符分类函数（头文件：ctype.h）

字符转换函数（头文件：ctype.h）

使用例（tolower）

内存函数

memcpy - 不重叠内存拷贝

解释函数

使用例

分析

模拟实现

拓展

memmove - 重叠内存拷贝

使用例

模拟实现

memcmp - 内存比较

使用例

memset - 内存设置

---

 

注：

 本笔记参考B站up鹏哥C语言的视频

字符分类函数（头文件：ctype.h）

函数	如果函数的参数符合下列条件就返回真
iscntrl	任何控制字符
isspace	空白字符：空格' '，换页'\f'，换行'\n'，回车'\r'，制表符'\t'，垂直制表符'\v'
isdigit	十进制数字0~9（不是指只能判断0~9）
isxdigit	十六进制数字，包括所有十进制数字，小写字母a~f，大写字母A~F
islower	小写字母a~z
isupper	大写字母A~Z
isalpha	字母a~z或者A~Z
isalnum	字母或者数字，a~z，A~Z，0~9
ispunct	标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符

字符转换函数（头文件：ctype.h）

int tolower( int c ); //转小写
int toupper( int c );//转大写

使用例（tolower）

#include<stdio.h>
#include<ctype.h>

int main()
{
	char arr[20] = { 0 };
	scanf("%s", arr);
	int i = 0;
	while (arr[i])
	{
		if (isupper(arr[i]))
		{
			arr[i] = tolower(arr[i]);
			printf("%c ", arr[i]);
		}
		i++;
	}

	return 0;
}

执行结果：

tosupper函数同理。

内存函数

memcpy - 不重叠内存拷贝

解释函数

将source指向的空间内存储的数据拷贝到destination指向的空间内，由num控制拷贝的数据量的大小。

由于strcpy函数存在限制，形参和返回类型均设置为char*，使用时难以实现诸如拷贝数组的功能，所以就需要memcpy函数。

譬如：

    int arr_1[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int arr_2[20] = { 0 };

将arr_1内的1~5拷贝到arr_2内，注意，arr_1内部的元素存储是：

01

00

00

00

02

00

00

00

03

00

00

00

……

会发现存在0，即 '\0' ，而strcpy函数在复制到 '\0' 时会结束，无法完成拷贝目标。

使用例

#include<string.h>

int main()
{
	int arr_1[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int arr_2[10] = { 0 };
	
	memcpy(arr_2, arr_1, 20);

	return 0;
}

开启调试，可以看见：

程序执行成功。

分析

memcpy函数在被设计时，是

void* memcpy(void* destination, const void* source, size_t num);

 全部由void*的指针进行接收，这样就不用在意接收的地址类型了。而由于void*的指针无法确定访问权限，所以再使用第三个参数num接收。

模拟实现

推荐书籍：《C语言深度解剖》

#include<assert.h>

void* my_memcpy(void* dest, const void* src, size_t num)
{
	assert(dest && src);//断言
	void* ret = dest;

	while (num--)//后置--：先进入循环，再--
	{
		*(char*)dest = *(char*)src;
		//((char*)dest)++;
		//((char*)src)++;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

int main()
{
	int arr_1[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int arr_2[10] = { 0 };

	int ret = my_memcpy(arr_2, arr_1, 20);

	return 0;
}

分析

• 实现函数时，要考虑函数参数问题，函数的参数使用void*。
• 同时，由于src内的数据不会改变，所以加上const。
• 加入第三个参数num控制被拷贝的数据量，认为num是只会是正数，所以类型是size_t。
• 最后是返回类型，因为希望得到返回值，所以返回类型使用void*。

强制类型转换是一种临时的转换：

ps：这里强制类型转换的优先级低于后缀++。

如：*(char*)dest，在进行解引用时，是把dest当作一个字符类型的指针进行解引用。

但是，如果出现：*(char*)dest++，这种用法在执行到++时，已经不存在强制类型转换了。

拓展

对于给定的数组

    int arr_1[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

要求把 1, 2, 3, 4, 5 拷贝到 3, 4, 5, 6, 7所在的空间内，即：

现在要如何传参？

尝试写法：

int ret = my_memcpy(arr_1 + 2 , arr_1, 20);

发现代码没有执行成功。

分析

由于src的空间和dest的空间存在重合时，异常出现。

当 1, 2 分别被拷贝到arr_1[2]、arr_1[3] 内时，接下来src调用的就是 arr_1[2] 的内容，此时arr_1[2] 内的数据已经被改变，调用的也是被改变后的内容。

结论：memcpy函数应该拷贝不重叠的内存。而接下来的memmove函数可以处理内存重叠的现象。

ps：在VS中，如果去尝试memcpy的库函数，会发现这是可以成功拷贝的。原因：memcpy函数的标准是只要可以实现不重叠拷贝就可以了，而VS中的实现即可以拷贝不重叠，也可以拷贝重叠内存。并不能保证所有平台的memcpy函数都可以实现重叠拷贝。

memmove - 重叠内存拷贝

memmove函数可以处理内存重叠的情况。

使用例

#include<string.h>
int main()
{
	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

	int ret = memmove(arr_1 + 2 , arr_1, 20);

	return 0;
}

开始调试：

拷贝成功。

模拟实现

#include<assert.h>

void* my_memmove(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(src && dest);
	if (dest < src)
	{
		//从前向后拷贝
		while (num--)
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else
	{
		//从后向前拷贝
		while (num--)
		{
			*((char*)dest + num) = *((char*)src + num);
			//num第一次进入时是19，小端存储模式使得这个位置是07 00 00 00中最后的一个00
			//一次循环num减1，自动找到下一个字节
		}
	}
	return ret;
}

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

	int ret = my_memmove(arr + 2, arr, 20);

	return 0;
}

分析：

现在不能使用my_memcpy中实现的从头往后一个一个拷贝的方式，那样会出现覆盖。思考新方法，发现：①源数据(src)可以从前向后拷贝，②也可以从后向前拷贝。

那么什么时候从前向后，什么时候从后向前？

从前向后拷贝：

举例

可以得出结论，只要dest在src前面，那么从后向前拷贝是行不通的。这时候就要从前向后拷贝。

从后向前拷贝：

举例

这时候就需要从后往前拷贝。但是还有一种情况：

这种情况src就和dest不相关了。这时候从前向后拷贝和从后向前拷贝都可以。

得出结论，从后往前拷贝可行的范围是

于是决定：

while (num--)
{
	*((char*)dest + num) = *((char*)src + num);
}

    num第一次进入时是19，小端存储模式使得这个位置是07 00 00 00中最后的一个00
    一次循环num减1，自动找到下一个字节

……

memcmp - 内存比较

ptr1：比较数据1            ptr2：比较数据2            num：要比较的数据字节数

• 比较数据相同，返回0；
• ptr1 > ptr2，返回一个大于0的数字；
• ptr1 < ptr2，返回一个小于0的数字。

使用例

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

int main()
{
	float arr_1[] = { 1.0, 2.0, 3.0, 4.0 };
	float arr_2[] = { 1.0, 3.0 };

	int ret = memcmp(arr_1, arr_2, 8);
	printf("%d\n", ret);

	return 0;
}

打印结果：

memset - 内存设置

把ptr所指向空间的前num个字节的内容设置成被指定的value值。（以字节为单位设置内存）

#include<string.h>

int main()
{
	int arr[10] = { 0 };

	//把数组arr的前20个字节全部设置成1
	memset(arr, 1, 20);

	return 0;
}

开始调试，发现：

右击鼠标，选择对应的十六进制显示：

会发现确实在每个字节内部放入一个1。打开内存，发现：