C语言复习第9章 字符串/字符/内存函数

朱一头zcy2024-11-08 18:34

目录

一、字符串函数

1.1 读取字符串gets

函数原型

char * gets ( char * str )

从标准输入读取字符 直到遇到换行字符或文件结束符

如果找到换行字符 则不将其复制到str中

在将字符复制到str后 会自动添加终止字符

请注意 gets与fgets完全不同：

gets不仅使用标准输入作为源 而且不将结束换行符的字符包含在生成的字符串中 也不允许指定str的最大大小（这可能导致缓冲区溢出）

简单来说gets就是读取一个字符串 包括空格 也读取 遇到\n或EOF就不读了

读到的内容给参数str

Example

1.2 字符串拷贝strcpy

函数原型

char * strcpy ( char * destination, const char * source )

  • 参数2拷贝给参数2 包括第一个\0
  • 第一个\0 也作为拷贝停止的标记
  • 参数1要足够大 以放得下参数2
  • 参数2一定要有结束标志\0 否则会出bug
  • 返回的是 参数1 也就是拷贝完之后的首字符地址
  • 参数1必须是可修改的字符串 不可以是常量字符串(不能被修改)


常量字符串无法被修改 这里的*p用const修饰是比较合理的

模拟实现

我的思路:

注意由于要返回destination 但是下面又改变了destination 所以需要暂存destination

擅于使用const(避免运行了才出错 直接编译不通过)

c 复制代码 
#define _CRT_SECURE_NO_WARNINGS 1

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

char* myStrcpy(char* destination,const char* source)
{
	assert(destination != NULL && source != NULL);
	assert(strlen(destination) >= strlen(source));

	char* ReturnValue = destination;
	//最后一次循环肯定是把第一个\0拷贝给destination了
	while (*destination = *source)
	{
		destination++;
		source++;
	}

	return ReturnValue;
}

int main()
{
	char ch1[] = "XXXXXXXXXXXXXXXXXXXXXXXXX";//big enough
	const char ch2[] = "zc231313y\0zcy";//只拷贝到第一个\0
	printf("%s\n", ch1);

	printf("%s\n", myStrcpy(ch1, ch2));
	printf("%s\n", ch1);
	return 0;
}

我的思路可以简化成下图:

可以但没必要啊!

另一种写法:

这种写法必须要注意 要单独拷贝一下'\0'

c 复制代码 
char* myStrcp(char* destination, const char* source)
{
	//返回值是destination的值(形参) 所以需要形参的值放起来
	char* des = destination;
	char* src = source;

	while (*src != '\0')
	{
		*des = *src;
		des++;
		src++;
	}
	//上面这种循环 当src指向\0的时候 不会进来 所以需要手动实现
	*des = '\0';  //or  *des = *src;
	return destination;//这样返回的 就是原来的形参 其实也就是ch1的首地址
}
int main()
{
	char ch1[] = "**************";
	char ch2[] = "zcygst";
	printf("qian:%s\n", ch1);

	myStrcp(ch1, ch2);
	printf("hou:%s\n", ch1);
    //或者 	printf("hou:%s\n", myStrcp(ch1, ch2));
    //这就是链式访问
    //%s就是从某个起始地址 一直打印到\0
    
	return 0;
}

官方源码

1.3 求字符串长度strlen

函数原型

size_t strlen ( const char * str )

  • 求第一次\0出现之前的字符个数 字符串的结束标志就是'\0'
  • 返回值是size_t(unsigned int) 因为字符串长度肯定不可能是负数
  • typedf unsigned int size_t

关于返回值size_与算术转换的一个易错点

  • 算术转换(>=int) 就高不就低
    size_t减去size_t 得到的东西肯定也是size_t
  • -3被理解成unsigned int 反正肯定不可能<0 所以会进入if 打印hehe

模拟实现:递归

注意不要忘记写else的return 0

如果传参的时候写++ 那必须是++s s++会导致死递归

下面三种代码 严格来说 返回值都应该是size_t

模拟实现:指针-指针

指针-指针=指针之间的元素个数 (希望求\0和首字符之间的元素个数)

模拟实现:暴力

不是\0就++
返回值应该是size_t或者unsigned int
count也最好定义成unsigned int 和返回值保持一致

官方源码

居然是我认为可读性较差的写法!

不过可能这个源码本来就不是给人读的

因为最后一次解引用发现是\0 之后又++了一次

所以最终eos指向\0下一个字符 返回的时候需要再-1

1.4 字符串追加strcat

函数原型

char * strcat ( char * destination, const char * source )

和strcpy非常相似

● arr目标空间要足够大 确保能放得下追加的结果

● 目标字符串要有\0 表示追加的起始位置

● 被追加的字符串也要有\0 表示追加的停止位置

● 两者都要有\0作为结束标志 因为两者都是字符串

● 目标字符串的\0会被覆盖

注意自己给自己追加的bug

由于追加的时候 会把自己的/0给覆盖 就找不到追加结束的时机了

所以自己给自己追加的时候 不要用strcat函数

模拟实现

一个易错点:

参考代码:

c 复制代码 
char* my_strcat(char* des, const char* sour)
{
	assert(des != NULL);
	assert(sour != NULL);
	
	//需要返回目标空间的起始地址
	char* ReturnVal = des;
	//des指向第一个\0 追加的字符由此开始覆盖
	des = des + strlen(des);
	//追加字符
	while (*sour)
	{
		*des = *sour;
		des++;
		sour++;
	}
	//上述循环并不会拼接\0 所以需要手动拼接
	*des = *sour;

	return ReturnVal;
}

int main()
{
	char ch[20] = "abcab\0cabc";
	my_strcat(ch, "zc\0yyy");
	printf("%s", ch);
	return 0;
}

其他写法:

1.5 字符串比较strcmp

函数原型

int strcmp ( const char * str1, const char * str2 )

返回值的含义

不关心字符串长度的

模拟实现

思路:

从首地址开始 一对一对字符作比较 相等就找下一对继续比较

但是注意::每次找下一对比较之前 必须看看上一对是不是\0 == \0

如果已经比较到\0 == \0 那就算字符串相等了 return 0即可

因为 \0就是字符串结束标志

也许\0后面还有字符 但是在strcmp眼里 字符串已经到头了 不关心后面的内容

参考代码:

c 复制代码 
int my_strcmp2(const char* ch1,const char* ch2)
{
	assert(ch1 && ch2);
	while (*ch1 == *ch2)
	{
		if (*ch1 == '\0')
		{
			//或者ch2 == \0  因为ch1 = ch2
			return 0;//能走到这 说明字符串完全一样
		}
		ch1++;
		ch2++;
	}
	//能走到这 说明*ch1 != *ch2
	return *ch1 - *ch2;//这里的返回值 也是符合strcmp的函数原型的
}
c 复制代码 
int my_strcmp1(const char* s1, const char* s2)
{
	assert(s1 != NULL);
	assert(s2 != NULL);
	//一对一对比较 ==就往后找
	while (*s1 == *s2)
	{
		//每次一进来先判断当前的==是不是由于\0==\0导致的
		//因为即使是"zcy\0asdasdads"
		//在strcmp眼里也只有zcy\0 第一个\0就是字符串的结束标志了
		if (*s2 == '\0')
			return 0;
		s1++;
		s2++;
	}

	//执行到这 说明*s1 != *s2已经出现了
	//字符串肯定不是相等的  再判断是>0还是<0就行了
	if (*s1 > *s2)
		return 1;
	else
		return -1;
}

1.6 长度受限制的字符串函数

上述函数的问题

strcat strcmp strcpy 都是一股脑找到\0才停下

长度不受限制 其实是很不安全的

比如说strcpy

它并不关心能不能放得下 反正目标是拷贝到\0

为了解决这些问题 引入了长度受限制的字符串函数: strncpy strncat strncmp

多了第三个参数 n 即需要操作的字符的个数

strncpy

char *strncpy( char *strDest, const char *strSource, size_t count )

如果够三个 那就拷贝abc 不会自己加\0

如果不够 那就补\0 缺几个补几个

strncat

char * strncat ( char * destination, const char * source, size_t num )

字面常量"defqwer" 其实本质是d的地址 从起始地址开始 往后追加4个 然后再补一个\0

因为追加完 肯定还是一个字符串 那就需要一个\0

当然如果不够4个 那追加到\0就停止了

从参数2往后n个字符的过程 遇到\0 就提前终止


strncmp

int strncmp ( const char * str1, const char * str2, size_t num )

比较arr1前四个和arr2前四个

即比较abcd和abcz

1.7 判断是否为子串strstr

函数原型

const char * strstr ( const char * str1, const char * str2 )

可能有多个子串 但只返回第一个子串的首地址

找不到 返回NULL

模拟实现

暴力法思路:

比如ABBBBCD和BCD

首先str1 和 str2 记录当前判断字符串的起始位置

tmp1 和 tmp2 真正的进行判断 同时都会++ 一对一对比较
每次比较完得出结果 都会更新str2的值(其实就是++) 然后把新的str赋给tmp
str2不会变 str1会+1+1+1+1...直到strlen(tmp1) >= strlen(tmp2)

比较思路:
如果*tmp1 = *tmp2了 而且*(tmp2 + 1) == '\0' 这就说明已经匹配成功

如果匹配失败 则需要让tmp2重回起点(即str2) 同时让tmp1指向str1的下一位

参考代码:

c 复制代码 
char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);

	const char* tmp1 = str1;
	const char* tmp2 = str2;
	//空串不做匹配
	assert((*str1 != '\0') && (*str2 != '\0'));

	while (strlen(tmp1) >= strlen(tmp2))
	{
		//比较当前tmp1和2锁定的字符串
		while (*tmp2 == *tmp1)
		{
			if (*(tmp2 + 1) == '\0')
				return (char*)str1;
			tmp2++;
			tmp1++;
		}
		//上一对匹配失败 寻找下一对(或者说这个str1不是匹配的起点 继续找下一个)
		str1++;
		
		//更新下标 重新开始匹配
		tmp1 = str1;
		tmp2 = str2;
	}

	return NULL;
}
	

int main()
{
	//char arr1[] = "hello world";
	//char arr2[] = "world";	
	char arr1[] = "abbbcdefbbc";
	char arr2[] = "bbc";
	char* p = my_strstr(arr1, arr2);
	if (p == NULL)//找不到返回的是空指针
	{
		printf("找不到\n");
	}
	else
	{
		printf("%s", p);//good,haha,good
	}
	return 0;
}

官方源码

思路:

cp在一个一个往后找(不用cp也行 可能是为了不改变形参的值 更规范)

然后cp找到的字符串和s2匹配

和我不同的是 它认为如果str2是空串 那直接返回str1的首地址 即空串是任何串的子串

这样理解确实更合理

下面匹配的思路跟我也有所不同

我认为调用strlen是节省开销 但是仔细一想好像不一定啊!

下图的思路就是如果*s1 == *s2 并且 s2还没有指向\0 那么s1 s2就成对的往前走 继续比较下一个字符

如果有一天内存while结束了 有可能是:

1.*s2指向\0了 那就说明上一对比较的s1 s2就是最后一对了 已经匹配成功

2.*s1 != *s2了 这种情况 就说明当前cp开始匹配的字符串就不是子串了 那就需要cp++继续下一对

3.外存循环的条件是cp没有指向\0 如果有一天能出了外存循环 就说明一直到cp指向\0 还没执行过return (cp) 那就不可能找到了 所以返回NULL

1.8 字符串分割strtock

函数原型

char * strtok ( char * str, const char * delimiters )

sep参数是个字符串 定义了用作分隔符的字符集合

第一个参数指定一个字符串 它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记

strtok函数找到str中的下一个标记 并将其用 \0 结尾 返回一个指向这个标记的指针 :下图就会找到第一个. 然后改成\0 并返回z的地址 这个时候用%s打印就是zcyxd

注：
strtok函数会改变被操作的字符串 所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改
第一次调用传参 没有传NULL:找到第一个分隔符 改为\0 并记住了这个位置
第二次调用传参 传的是NULL:记住了第一次\0的位置 从下一个字符串开始再找分隔符 上图就是从\0往后找 找到一个foxmail 然后把第二个.换成\n 同时返回f的地址 并记录这次\0的位置
第2+n次调用传参传的都是NULL: 都会重复上述动作 直到找不到分隔符了 那就开始返回NULL
\0不能作为分隔符 都说了是字符串!! 字符串的结束标志就是\0!!

正确的打开方式

这个函数仿佛有记忆功能

所以猜测里面应该有一个static静态变量

要不然每次调用 函数栈帧都会销毁的

一开始就传参arr2 且只需要调用一次

之后每次都用NULL作为参数 调用一次打印一次 直到返回值是NULL
每次都会拿到一个子串的首地址

打印 或者是拷贝到别的地方 就看具体需求了

1.9 返回错误码所对应的错误信息strerror

函数原型

char * strerror ( int errnum )

● 文件如果打开失败 fopen()会把错误码放到全局变量errno(errno.h) 里面去

● 返回NULL就说明打开失败了 strerror就能把错误码转换成错误信息 可以得知为什么打开失败了

这样写只知道打开失败了 但是 不知道为什么

perror更佳(stdio.h)

它会自己主动去捕获errno的错误码
perror的头文件是:stdio.h

strerror只是获得错误信息的起始地址 不会打印

perror拿到错误信息 会直接打印出错误信息

二、字符函数

2.1 字符分类函数(ctype.h)

函数:如果他的参数符合下列条件就返回真(非0)

常用:
isdigit:十进制数字 0~9
islower:小写字母a~z
isupper:大写字母A~Z
isalpha:字母a-z或A-Z
isalnum:字母或者数字 a-z或A-Z或0-9

了解:
isxdigit:是不是十六进制数字 包括所有十进制数字，小写字母a-f，大写字母A-F
ispunct:标点符号 任何不属于数字或者字母的图形字符
isgraph:任何图形字符
isprint:任何可打印字符 包括图形字符和空白字符
iscntrl:任何控制字符
iscntrl:任何控制字符

判断是不是小写 不是就返回0 否则是非0

2.2 字符转换(ctype.h)

c 复制代码 
int tolower ( int c );
int toupper ( int c );

可以看出 都是值传递

所以只会返回当前字母对应的大小写字母的码值

并不会直接修改 当前字母

三、内存函数

3.1 memcpy

函数原型

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

● strcpy只能拷贝字符串 如果我想拷贝其他类型的呢?

● 拷贝12345 --一共20个字节

● 指针变量的一个优势

模拟实现

写法1:

c 复制代码 
void* my_memcpy(void* destination, const void* source, size_t num)
{
	char* start1 = (char*)destination;
	char* start2 = (char*)source;

	for (int i = 0; i < num; i++)
	{
		*start1 = *start2;
		start1++;
		start2++;
	}

	//返回目标des的地址(初始状态的)
	return destination;
}

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[10] = { 0 };
	my_memcpy(arr2, arr1 + 2, 12);
	return 0;
}

写法2:

有一个注意点

这种写法是临时的强转 dest++的时候
dest的类型仍然是void* 是不可以++的


这样才对 前置对 后置不对

自己给拷贝给自己的一个问题

● 这里实际上拷贝的是1 2 1 2 1

● 内存重叠-->memmove

3.2 memmove

函数原型

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

memmove已经包含了memcpy的功能

但是他能实现重叠内存的拷贝

但是实际上:

C语言对memcpy的要求只有60分

但是 在VS里 VS对memcpy的实现有一百昏!

所以在VS里用memcpy 并不会出现3.1的问题

模拟实现

需要分情况讨论:

  1. 如果dest在src的左边 从src开始 按顺序从左往右拷贝给dest即可
  2. 如果dest在src的右边 从src最右边的7开始 从dest最右边开始 从右往左把src的值拷贝给dest
  3. 总结 其实右三种可能
    即dest在src的左边:前-->后
    dest在src之间:后-->前
    deest在src末尾的右边-->不重叠 无所谓
  1. 注意要么dest和src都从右 要么都从左

参考代码:无所谓的时候选后-->前 选src作为分界处

c 复制代码 
void* my_memmove(void* des, const void* src, size_t num)
{
	assert(des && src);
	char* src2 = (char*)src;
	char* des2 = (char*)des;

	//目标地址在src左边 从低到高拷贝(从前到后)
	if (des < src)
	{
		for (int i = 0; i < num; i++)
		{
			*des2 = *src2;
			des2++;
			src2++;
		}
	}

	//这里des==src的情况 其实可以直接不拷贝
	//否则从高到到低拷贝(从后到前) 
	else
	{
		for (int i = num - 1; i >= 0; i--)
		{
			*(des2 + i) = *(src2 + i);
		}
	}

	return des;
}

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

另一种写法:

如果是写给别人看的 比如考试 建议用for

如果只是实现一个函数给别人用 这个也好

3.3 memcmp

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

一个字节一个字节比较(其实大小端的比较结果都是一样的) 当==的时候 继续往下比较

3.4 memset

void * memset ( void * ptr, int value, size_t num )

以字节为单位 来设置内存中的数据



这是按照字节处理 的 1写成俩16进制位就是01

但是数组元素每个都是4字节 是01010101对应的十进制


注意第二个参数是int char也属于整型家族

一般memset这么用 把每个字节都改成0

每个字节都变成0 相当于每个元素都是0

相关推荐
网易独家音乐人Mike Zhou3 小时前
【卡尔曼滤波】数据预测Prediction观测器的理论推导及应用 C语言、Python实现（Kalman Filter）
c语言·python·单片机·物联网·算法·嵌入式·iot
搬砖的小码农_Sky6 小时前
C语言：数组
c语言·数据结构
ahadee10 小时前
蓝桥杯每日真题 - 第19天
c语言·vscode·算法·蓝桥杯
Theliars10 小时前
C语言之字符串
c语言·开发语言
Reese_Cool10 小时前
【数据结构与算法】排序
java·c语言·开发语言·数据结构·c++·算法·排序算法
搬砖的小码农_Sky11 小时前
C语言：结构体
c语言·数据结构
平头哥在等你13 小时前
求一个3*3矩阵对角线元素之和
c语言·算法·矩阵
尹蓝锐13 小时前
C语言-11-18笔记
c语言
ahadee13 小时前
蓝桥杯每日真题 - 第18天
c语言·vscode·算法·蓝桥杯
就爱六点起14 小时前
C/C++ 中的类型转换方式
c语言·开发语言·c++
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作