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

一、字符串函数

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(避免运行了才出错 直接编译不通过)

#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’

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函数

模拟实现

一个易错点:

参考代码:

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眼里 字符串已经到头了 不关心后面的内容

参考代码:

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的函数原型的
}

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的下一位

参考代码:

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)

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:

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末尾的右边–>不重叠 无所谓

4. 注意要么dest和src都从右 要么都从左

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

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