memcpy、memmove、memcmp、memset- -字符函数和字符串函数3

• 字符分类函数
  isdigit 检查字符是否为十进制数字
  islower 小写字母a~z
  isupper 大写字母A~Z
• 字符转换 tolower toupper
• 内存函数
  memcpy- -拷贝字符串- -类型任意- -不能处理内存重叠的拷贝
  memmove- -可以处理内存重叠的拷贝
  memcmp- -比较内存中的数据
  memset- -以字节为单位来设置内存

拓展知识点

iscntrl 任何控制字符
isspace 空白字符：空格‘ ’，换页‘\f’，换行’\n’，回车‘\r’，制表符’\t’或者垂直制表符’\v’
isdigit 十进制数字 0~9
isxdigit 十六进制数字，包括所有十进制数字，小写字母a_{f，大写字母A}F
islower 小写字母a~z
isupper 大写字母A~Z
isalpha 字母a_z或AZ
isalnum 字母或者数字，a_z,AZ,0~9
ispunct 标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph 任何图形字符
isprint 任何可打印字符，包括图形字符和空白字符

字符分类函数

isdigit

#include <ctype.h>
int main()
{
	char ch = '2';
	int ret = isdigit(ch);
	printf("%d\n", ret);
	return 0;
}

• 返回值：如果是数字字符返回非0的值，如果不是数字字符返回0.

islower

int main()
{
	char ch = 'a';
  int ret = islower(ch);
	printf("%d\n", ret);
	return 0;
}

• 如果是小写字母返回非0的值，如果不是小写字母，返回0

字符转换函数

int tolower ( int c );

int toupper ( int c )

- 大写转换为小写 - -tolower

- 小写转换为大写- -toupper

int main()
{
	char arr[20] = { 0 };
	scanf("%s", arr);
	int i = 0;
	while (arr[i] != '\0')
	{
		if (isupper(arr[i]))//判断是不是大写字母
		{
			arr[i] = tolower(arr[i]);//是的话就转换为小写字母
		}
		printf("%c ", arr[i]);
		i++;
	}
	return 0;
}

内存转换函数

1、memcpy- -拷贝的类型可以任意

strcpy拷贝问题的解释之为什么要用memcpy来拷贝

int main()
{
	int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int arr2[20] = { 0 };
	//strcpy()
	//char* strcpy(char* dest, const char* src)
	return 0;
}

• 假设为小端存储01 00 00 00 02 00 00 00 …当在内存中一个一个字节的拷贝完一个字节以后00会为\0，strcpy出现\0会拷贝停止
• //strcpy()
  //char* strcpy(char* dest, const char* src)
  而且这个时候是两个整型数组，传参的时候用字符指 针显然错误

所以使用内存·拷贝函数memcpy

• void * memcpy ( void * destination, const void * source, size_t num )- -void可以运用于任何类型- -内存中的类型不知道- -可以使用- -而strcpy需要知道类型

• 拷贝的src只是拷贝过去，并不会发生改变，所以加const更安全，返回的时候返回目标空间的起始地址，所以用void * 更加靠谱

• 函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。

• 这个函数在遇到 ‘\0’ 的时候并不会停下来。
  如果source和destination有任何的重叠，复制的结果都是未定义的。

模拟实现函数
把src的字符拷贝到目标空间dest中

#include <assert.h>
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] = { 1,2,3,4,5,6,7,8,9,10 };.
	int arr2[20] = { 0 };
   my_memcpy(arr2,arr1,num);
	return 0;
}

• -* ( char* )dest = * (char * )src;转换为char *类型后再解引用找到那个字节
• 转换为char *类型是为了一个字节一个字节的拷贝
• void* ret = dest;因为dest在过程中会往后走，所以先把它的起始空间存储起来，这样可以让它返回的时候直接返回起始空间

• num为20的意思是拷贝前20个字节的元素拷贝过去即把五个元素拷贝过去
• 无符号类型- -size_t
  函数的错误写法
• void类型不能解引用- -错误

*dest=*src
dest++;
src++;

• 单目运算符从右向左- -会出错

*(char *)dest++=*(char *)src++

---

区分memcpy和memove

1. 我们自己写的memcpy自身拷贝- -源头和目的地重叠会出错

2. 有数组1 2 3 4 5 6 7 8 9 10想要把1 2 3 4 5 拷贝到3 4 5 6 7,即输出为 1 2 1 2 3 4 5 8 9 10

3. 首先把1 2拷贝到3 4，到3 4拷贝的时候拷贝的不是原4的内容了，而是刚开始拷贝到3 4的1 2，就会一直拷贝1 2

4. 所以最好遵守：
   memcpy函数应该拷贝不重叠的内存
   memmove函数可以处理内存重叠的情况

5. 特殊讲解
   用库函数memcpy在vs中按照memmove的要求是可以重叠拷贝的，但在别的平台不一定，所以最安全是用memmove- -处理内存重叠的拷贝

---

2、memmove- -可以处理内存重叠的拷贝

模拟实现
把src的字符拷贝到目标空间dest中

void* my_memmove(void* dest, const void*src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	if (dest < src)
	{
		//前->后
		while (num--)//一个字节一个字节的拷贝
		{
			*(char*)dest = *(char*)src;
			dest = (char*)dest + 1;
			src = (char*)src + 1;
		}
	}
	else 
	{
		//后->前- -必须先找到src的最后一个字节，再找到dest的最后一个字节，然后从后向前拷
		while (num--)//19
		{
			*((char*)dest + num) = *((char*)src + num);
		}
	}
	return ret;
}

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

• *((char * )dest + num) = * ((char * )src + num);
  -while( n- -) ： 减号在后 就是 后递减 表达的意思 是先运算后递减
  先运算 ：把n的值作为判断条件，即非 0 都为真
  后递减 ：在判断为真后，将n递减
  （也就是 n本身的值 是作为判断 while() 语句是否为真 的依据， 在判断为真后 将n递减，并非 将n递减 后的值作为判断依据 （铭记 n-- 表达的是 后递减））
  图解：
  

3、memcmp- -比较内存中的数据

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

• 比较从ptr1和ptr2指针开始的num个字节
• 只是比较，不会改变，参数用const较安全

float- -四个字节

int main()
{
	float arr1[] = { 1.0, 2.0,3.0,4.0 };
	float arr2[] = { 1.0, 3.0 };
	int ret = memcmp(arr1, arr2, 4);
	printf("%d\n", ret);

	return 0;
}

• 比较前四个字节（float类型所以比较的是1.0）相同返回为0

4、memset- -以字节为单位来设置内存

• 把ptr所指向的空间的前num个字节设置为value值

int main()
{
	//40
	int arr[10] = { 0 };//20
	memset(arr, 1, 20);//以字节为单位设置内存的
	return 0;
}

20个字节每个字节设置为1
内存中观察：

监视中观察

注：如果想每个元素设置为1在整型数组这里就不可以，但是为字符数组就可以
有错误的地方虚心等待指正，感谢看了本篇文章！！