前言

之前我们用两篇文章介绍了strlen、strcpy、stract、strcmp、strncpy、strncat、strncmp、strstr、strtok、streeror这些函数

第一篇文章strlen、strcpy、stract

第二篇文章strcmp、strncpy、strncat、strncmp

第三篇文章strstr、strtok、streeror

今天我们就来学习字符分类函数、字符转换函数、内存访问函数

话不多说，我们直接开始

字符分类函数

这些函数需要包含头文件<ctype.h>

例子（islower）

用islower函数作为例子

当字符是小写字母时，返回一个非零的整数，
当不是小写字母时，返回0

int main()
{
	char ch = 'w';
	int ret = islower(ch);

	printf("%d\n", ret);

	return 0;
}

字符转换函数

一般使用

转换单个字符

int main()
{
	char ch = 'W';
	char ret = tolower(ch);

	printf("%c\n", ret);

	return 0;
}

转换字符串

int main()
{
	char arr[] = "HELLO WORLD";
	int i = 0;
	while (arr[i])
	{
		if (isupper(arr[i]))
		{
			arr[i] = tolower(arr[i]);
		}
		i++;
	}

	printf("%s\n", arr);

	return 0;
}

内存访问函数

我们接下来会学习：memcmp、memmove、memcmp、memset函数

引入

小明提出疑问：
我们之前已经学习了那么多的字符串函数：strlen、strcpy、stract、strcmp、strncpy、strncat、strncmp…为什么还要学习内存函数呢

那是因为，上面的那些函数，操作对象都是字符串，也大多需要用到’\0’
而当我们要对整型数组或者结构体的数组，这时我们在用之前的那些函数就做不到了

下面看一段代码，它能达到我们预想的结果吗

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[5] = { 0 };

	strcpy(arr1, arr2);

	return 0;
}

程序警告：

原因

上面我们学习过：strcpy函数的参数是：char* dest, const char* src
而下面这行代码：

	strcpy(arr1, arr2);

就是在把一个整型元素传给一个char*指针的元素

并且，我们知道strcpy在遇到’\0’就停止拷贝以及strcpy的操作单位大小是一个字节

那么如图，整型数据在小端模式下存储的方式如图：

当拷贝完01后，遇到了00，我们都知道’\0’的ASCII码值是0，所以这就相当于拷贝结束，所以对于非字符数组，strcpy是无法使用的

这时，我们就要使用上文提到的内存函数了

memcmp

内存拷贝函数：可以拷贝任何类型的数据

此处联系之前学习的知识，就可以知道参数的类型是void*，
后面的num是需要拷贝的字节数

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

使用示例

下面介绍两个例子：拷贝整型数据、拷贝结构体类型数据

-struct Stu
{
	char name[20];
	int name;
};

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[5] = { 0 };
	struct Stu arr3[] = { {"zhang", 20}, {"wang", 15},{"li", 25} };
	struct Stu arr4[] = { 0 };

	memcpy(arr1, arr2, sizeof(arr1));
	memcpy(arr3, arr4, sizeof(arr3));

	return 0;
}

模拟实现

问题：
因为是void*类型的参数，所以我们这里既不能解引用、又不能与整数运算

所以我们就从第三个参数num入手，既然我不知道要拷贝的元素类型是什么，那么就以字节为单位进行拷贝，这样肯定就没问题了

	*(char*)dest = *(char*)src;//处理赋值问题

	++(char*)dest;//处理运算问题
	++(char*)src;

初步代码

void* my_memcpy(void* dest, const void* src, int num)
{
	assert(dest && src);//断言好习惯
	void* ret = dest;//存储首元素，方便拷贝之后打印
	while (num--)
	{
		*(char*)dest = *(char*)src;
		++(char*)dest;//强制类型转换的优先级比++要低，所以++要写在前面
		++(char*)src;
	}
	return dest;
}

一些重点提示

特殊使用

在下面这个字符串中，我想要将1，2，3，4，5拷贝到3，4，5，6，7的位置上，怎么实现呢（使用my_memcpy函数）

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

像下面这么写可以吗？

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

	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}

	return 0;
}

运行结果：

咦？那这是为什么？

原因

初步说明：
源数据和目的地数据有关系：当想将3复制到5的地址处时，3已经在之前被替换成1了，所以结果就不对

解决方法

那么如果我们从后向前复制，是不是就可以解决了，先将5复制到7，4复制到6，以此类推

但这种方法也是有漏洞的，当要拷贝的源数据，在目的地数据之前时，程序也会出问题

所以，要根据实际情况来判断，但是有另外的函数来处理这种重叠拷贝的问题
下面我们就来学习memmove函数

注意

虽然使用memcpy函数去执行上面的操作也是可以实现的
但C语言标准中规定，memcpy函数只用来处理内存不重叠的拷贝
memmove函数是用来处理重叠内存的拷贝的

memmove

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

使用示例

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	memmove(arr1 + 2, arr1, 20);

	return 0;
}

运行结果：

模拟实现

思路分析

分三种情况讨论

1

dest的地址小于src，也就是dest指向的元素在src指向的元素的左边
就从前向后拷贝

2

dest的地址大于src，也就是dest指向的元素在src指向的元素的右边
就从后向前拷贝

3

拷贝的内容无内存重叠，怎么拷贝都可以

最终代码

此处只提供一种分类方式，还有其他的分类方式，都可以
（就是需要注意在进行整数运算的时候，需要进行强制类型转换）

void* my_memmove(void* dest, const void* src, size_t count)
{
	assert(dest && src);
	void* ret = dest;
	if (dest < src)//从前向后
	{
		while (count--)
		{
			*(char*)dest == *(char*)src;
			++(char*)dest;
			++(char*)src;
		}
	}
	else//从后向前
	{
		while (count--)//count改变，dest和src就不用改变了
		{
			*((char*)dest + count) = *((char*)src + count);
		}

	}
	return ret;
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	my_memmove(arr1 + 2, arr1, 20);

	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}

	return 0;
}

memcmp

简单了解一下即可

介绍

定义如下

int memcmp ( const void * ptr1, 
 			const void * ptr2, 
			size_t num );

num是比较的字节个数

返回值

返回值与strcmp函数的返回值判定方式相同，

memset

内存设置函数

介绍

作用：设置缓冲区作为特殊的字符

参数：

dest：目的地，即要修改哪块空间
c：要设置的字符是什么
count：要设置的字符数，单位是字节

使用

int main()
{
	char arr[10] = "";
	memset(arr, '#', 10);

	return 0;
}

运行过程：

注意事项

观察下面这段代码，运行结果是什么？

int main()
{
	int arr[10] = { 0 };
	memset(arr, 1, 10);
	
	printf("%d\n", arr[0]);
	return 0;
}

输出结果：

这是因为，参数中count单位是字节
上面的代码是将前十个字节改成了1，也就是十六进制的01 01 01 01

结语

关于函数的介绍到这里就结束了，希望你有所收获
之后我们会学习自定义数据类型：结构体，
我们下篇文章见