目录
注:
本笔记参考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。打开内存,发现: