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

一、字符串函数
- [1.1 读取字符串gets](#1.1 读取字符串gets)
- - 函数原型
  - Example
- [1.2 字符串拷贝strcpy](#1.2 字符串拷贝strcpy)
- [1.3 求字符串长度strlen](#1.3 求字符串长度strlen)
- [1.4 字符串追加strcat](#1.4 字符串追加strcat)
- [1.5 字符串比较strcmp](#1.5 字符串比较strcmp)
- [1.6 长度受限制的字符串函数](#1.6 长度受限制的字符串函数)
- [1.7 判断是否为子串strstr](#1.7 判断是否为子串strstr)
- [1.8 字符串分割strtock](#1.8 字符串分割strtock)
- - 函数原型
  - 正确的打开方式
- [1.9 返回错误码所对应的错误信息strerror](#1.9 返回错误码所对应的错误信息strerror)
- - 函数原型
  - perror更佳(stdio.h)
二、字符函数
- [2.1 字符分类函数(ctype.h)](#2.1 字符分类函数(ctype.h))
- [2.2 字符转换(ctype.h)](#2.2 字符转换(ctype.h))
三、内存函数
- [3.1 memcpy](#3.1 memcpy)
- [3.2 memmove](#3.2 memmove)
- - 函数原型
  - 模拟实现
- [3.3 memcmp](#3.3 memcmp)
- [3.4 memset](#3.4 memset)

一、字符串函数

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的问题

模拟实现

需要分情况讨论:

如果dest在src的左边 从src开始 按顺序从左往右拷贝给dest即可

如果dest在src的右边从src最右边的7开始从dest最右边开始 从右往左把src的值拷贝给dest

总结其实右三种可能
即dest在src的左边:前-->后
dest在src之间:后-->前
deest在src末尾的右边-->不重叠 无所谓

注意要么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

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

目录

一、字符串函数

1.1 读取字符串gets

函数原型

Example

1.2 字符串拷贝strcpy

函数原型

模拟实现

官方源码

1.3 求字符串长度strlen

函数原型

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

模拟实现:递归

模拟实现:指针-指针

模拟实现:暴力

官方源码

1.4 字符串追加strcat

函数原型

注意自己给自己追加的bug

模拟实现

1.5 字符串比较strcmp

函数原型

返回值的含义

模拟实现

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

上述函数的问题

strncpy

strncat

strncmp

1.7 判断是否为子串strstr

函数原型

模拟实现

官方源码

1.8 字符串分割strtock

函数原型

正确的打开方式

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

函数原型

perror更佳(stdio.h)

二、字符函数

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

2.2 字符转换(ctype.h)

三、内存函数

3.1 memcpy

函数原型

模拟实现

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

3.2 memmove

函数原型

模拟实现

3.3 memcmp

3.4 memset

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