字符函数和字符串函数：memcpy、my_memcpy、memmove、my_memmove——《初学C语言第41天》

////——————对字符进行函数操作时，函数厚的括号内需使用单引号：isspace('s')

////函数          判断        如果他的参数符合下列条件就返回真（非0），不符合返回0

////（判断函数是不是后续对应的参数）

// //注意头文件的引用

////iscntrl        任何控制字符

////isspace        空白字符：空格‘ ’,换页‘\f’,换行'\n',回车‘\r’,制表符'\t',垂直制表符'\v'...

////isdigit        十进制数字 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     任何可打印字符，包括图形字符和空白字符

////举例isxdigit

//#include<stdio.h>

//#include<ctype.h>//isspace需引用对应头文件

//int main()

//{

// const int a = isxdigit('F');

// printf("%d\n", a);

// return 0;

//}//isdigit('')括号内为数字字符（0至9），返回非0，不是数字字符，返回0

////isxdigit('')括号内为数字字符（16进制数，a~f，A~F），返回非0，不是数字字符，返回0

//// 举例isspace

//#include<stdio.h>

//#include<ctype.h>//isspace需引用对应头文件

//int main()

//{

// int a = isspace(' ');

// printf("%d\n",a);

// return 0;

//}//isspace(' ')中（）内部是空白字符返回0，不是空白字符返回非0的数

////字符转换函数：1.tolower：转小写   2.toupper ：转大写

////注意：(只针对一个字符进行操作，放入多个字符不执行，放入字符串只会输出最后一个字符，并不会对其有任何更改)

////大小写转换也可以对其进行ASCII值+/-32进行更改，但需注意占位符的使用（大写的<小写的ASCII值）

////当进行转换时：若参数为非字母大小写（例如@，#）或小写转小写时，打印结果与参数形同，不会转变

//#include<stdio.h>

//#include<ctype.h>//isspace需引用对应头文件

//int main()

//{

// printf("%c\n", toupper('g'));//转大写

// return 0;

//}

//////memcpy(内存拷贝)——memory copy——头文件<memory.h>或<string.h>

////负责拷贝两块独立空间中的数据，不负责重叠拷贝（但memcpy与memmove都可以完成重叠拷贝）

//// 但是模拟实现的my_memcpy不能够实现重叠，因为C语言对于memcpy的要求中没有重叠，

//// 所以模拟实现的时候并没有去涉及此项功能的模拟

////由于strcpy与strncpy只能拷贝字符/字符串，所以引入memcpy(可以拷贝所有类型的数据)

//// 原理：拷贝其需要被拷贝(源数据)的内存

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

////用const是因为源数据我们并不会去改变并且不能改变，所以用const来保护源数据

////用void*的原因是为了通用（void*为通用类型的指针），可以在一个程序中同时拷贝任意类型字符

////void* destination:目的地

////const void *source：源数据

//// size_t num：字节数（要拷贝几个字节）,注意使用memcpy需考虑字节数的计算，例如int：4字节

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

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

////这个函数在遇到 '\0' 的时候并不会停下来。

////如果source和destination有任何的重叠，复制的结果都是未定义的。

////举例：使用memcpy拷贝整型数组

//#include <stdio.h>

//#include <memory.h>

//int main()

//{

// int arr1[] = { 1,2,3,4,5 };

// int arr2[20] = {6};

// memcpy(arr2, arr1,20);

// int i = 0;

// for(i=0;i<5;i++)

// {

//  printf("%d", arr2[i]);//打印数组要带下标！！！！！！！

// }

// return 0;

//}

//#include <stdio.h>

//#include <string.h>

//#include<assert.h>

//void* my_memcpy(void* dest, const void* src, size_t num)//void*的指针不能直接进行解引用

////由于我们未知拷贝数据的类型而采用了void*，所以我们一个字节一个字节的拷贝

//{

// assert(dest && src);//指针变量不能为空，即dest和src不能为NULL（而不是指针指向的内容（*src/*dest）不能为空）

// void* ret = dest;

// while (num--)//拷贝n对整型

// {

//  *(char*)dest = *(char*)src;

////此处使用(char*0)的理由是，当我们的字节数num为部分类型所不能整除时（int为4字节，num=19，无法整除）

////会超出范围，而由于char*的变化量最小，所以是未知类型情况下最好的类型转换的选择

//  //(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[5] = {6,7,8,9};

// my_memcpy(arr1,arr2,19);

// //一个int为4字节，当n-1个int的字节数<num（字节数）<n个int的字节数，按n个整型计算.

// // 但是为了规避这个问题，我们直接进行强制类型转换为char*，这样就不会有超出范围的情况了

// my_memcpy(arr1+2, arr1, 20);//重叠：自己给自己拷贝。把arr1的数据从数组元素3的位置拷贝到7的空间上去

// //即      1 2 3 4 5 6 7 8 9 10

// //            1 2 3 4 5

// //结果：  1 2 1 2 1 2 1 8 9 10

// // 拷贝时已将把12345的数据拷贝到34567的位置上，此时的34已经变成了12，而5是对应3的拷贝，可是3已经变成了1

// // 所以同理推断可知34567在准备拷贝12345内容之前，345就已经被拷贝了新的数据，从而并不能达到理想化的结果

// int i = 0;

// for(i=0;i<10;i++)

// {

//  printf("%d\n", arr1[i]);//打印数组要带下标！！！！！！！

// }

// return 0;

//}

//////memmove（重叠内存的拷贝）基本同于memcpy

// 重叠拷贝的拷贝顺序问题：dest>src从后向前拷贝，dest<src从前向后拷贝

////void * memmove ( void* dest, const void* src, size_t num );

////和memcpy的差别就是memmove函数处理的源数据（源内存块）和目标数据（目标内存块）是可以重叠的。

////如果源空间和目标空间出现重叠，就得使用memmove函数处理。

//#include <stdio.h>

//#include <string.h>

//int main()

//{

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

// int arr2[5] = { 1,2,3,4,5 };

// memmove(arr1 + 2, arr1, 20);//重叠：自己给自己拷贝。把arr1的数据从数组元素3的位置拷贝到7的空间上去

// int i = 0;

// for (i = 0; i < 10; i++)

// {

//  printf("%d\n", arr1[i]);//打印数组要带下标！！！！！！！

// }

// return 0;

//}

//////模拟实现memmove

//#include <stdio.h>

//#include <string.h>

//#include<assert.h>

//void* my_memmove(void* dest, const void* src, size_t num)//void*的指针不能直接进行解引用

//{

// void* ret = dest;

// assert(dest && src);

// if (dest < src)

// {

//  while (num--)//从前往后拷贝n对整型

//  {

//   *(char*)dest = *(char*)src;//实现对应位置拷贝

//   dest = (char*)dest + 1;

//   src = (char*)src + 1;

//  }

// }

// else

// {

//  while (num--)//从后往前拷贝n对整型

//  {

//   *((char*)dest + num) = *((char*)src + num);//此处由于是倒序拷贝所以就不需要借助自增或自减进行赋值了

//  }

// }

// return ret;//拷贝函数记得返回起始地址

//}

//int main()

//{

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

// my_memmove(arr1+2, arr1, 20);//重叠：自己给自己拷贝。把arr1的数据从数组元素3的位置拷贝到7的空间上去

// int i = 0;

// for (i = 0; i < 10; i++)

// {

//  printf("%d\n", arr1[i]);//打印数组要带下标！！！！！！！

// }

// return 0;

//}