字符串和内存函数

目录

本章重点

一 函数介绍

1.1 strlen

1.2 strcpy

1.3 strcat

1.4 strcmp

1.5 strncpy

1.6 strncat

1.7 strncmp

1.8 strstr

1.9 strtok

1.10 strerror

字符分类函数 

 字符转换函数

1.11 memcpy

1.12 memmove

1.13 memcmp

1.14 memset 

二 库函数的模拟实现

2.1 模拟实现strlen

2.2 模拟实现strcpy

2.3 模拟实现strcat

2.4 模拟实现strstr

2.5 模拟实现strcmp

2.6 模拟实现memcpy

2.7 模拟实现memmove

---

励志环节

发光并非太阳的专利，大家都可以。

---

本章重点

重点介绍处理字符和字符串的库函数的使用和注意事项

求字符串长度 strlen
长度不受限制的字符串函数 strcpy strcat strcmp
长度受限制的字符串函数介绍strncpy strncat strncmp
字符串查找 strstr strtok
错误信息报告 strerror
字符操作
内存操作函数 memcpy memmove memset memcmp

---

C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在
常量字符串中或者字符数组中。
字符串常量 适用于那些对它不做修改的字符串函数.

一 函数介绍

1.1 strlen

   在前面的文章中，介绍了三种方法实现strlen:(1)计数器的方法（2）递归的方法 (3)指针-指针的方法。

size_t strlen ( const char * str ); 

 sizeof 是一个操作符，返回的结果为size_t    （size_t专门为sizeof的返回值设计的） 

size_t 相当于unsigned int 

库函数strlen返回值 是size_t,所以 strlen 不能用于加减：strlen("abc") - strlen("abcdefg") 结果会是一个size_t 类型的数，不会是-4    (解决办法，可以强制转换） 

字符串以'\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数（不包含 '\0' )

参数指向的字符串必须要以 '\0' 结束。

注意函数的返回值为size_t，是无符号的（ 易错 ）
学会strlen函数的模拟实现

1.2 strcpy

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

源字符串必须以 '\0' 结束。
会将源字符串中的 '\0' 拷贝到目标空间。
目标空间必须足够大，以确保能存放源字符串。（strlen不管目标空间可以可以放进去，但是我们要保证目标空间足够大，以便能放进去）
目标空间必须可变。
学会模拟实现

1.3 strcat

追加一个字符串

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

源字符串必须以 '\0' 结束。没有\0的话，就无法追加，打印不出来。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
字符串自己给自己追加，如何？

代码展示：

#include 
int main()
{
	char arr1[30] = "hello";
	char arr2[] = "world";
	strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

1.4 strcmp

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

第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字

strcmp(s1, s2),比较字符串的大小，两个字符串从左向右逐个字符相比（按ASCII的值大小相比），直到某一个字符不相等或者其中一个字符串比较完毕才停止比较，字符的比较为ASCII码的比较（若字符串1大于字符串2，返回结果大于0，若字符串1小于字符串2，返回结果小于0，若字符串1等于字符串2，返回结果等于0.）

strcmp的头文件是

1.5 strncpy

char * strncpy ( char * destination, const char * source, size_t num );

拷贝num个字符从源字符串到目标空间。
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加'\0'，直到num个。

1.6 strncat

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

追加字符，追加num个字符从源字符串到目标空间。
如果源字符串的长度大于num，则追加num个源字符串之后，再在后边一个加'\0'。

如果源字符串的长度小于num，则追加完源字符串之后，再在后边加一个'\0'，别的就不管了。

1.7 strncmp

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

比较num个字符

1.8 strstr

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

字符串查找函数，在str1中找str2,返回在str1中第一次出现str2的地址。找不到返回空指针。

代码展示：

#include 
int main()
{
	char arr1[] = "abcdabcd";
	char arr2[] = "cd";
	char* ret = strstr(arr1, arr2);
	if (ret == NULL)
		printf("找不到");
	else
		printf("%s\n", ret);
	return 0;
}

1.9 strtok

char * strtok ( char * str, const char * sep );

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

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

（3）strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针（注： strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容 并且可修改。）

把标记内容改成\0，会改变字符串的内容，所以把字符串临时拷贝。

（4）strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串 中的位置。

（5）strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标 记。

（6）如果字符串中不存在更多的标记，则返回 NULL 指针。

1 strtok函数找第一个标记的时候，函数的第一个参数不是NULL

2 strtok函数找非第一个标记的时候，函数的第一个参数是NULL

代码展示：

 

#include 
int main()
{
	const char* p = "@.";
	char arr[] = "[email protected]";
	char buf[50] = { 0 };//因为字符串会被修改，所以要吧arr临时拷贝到buf里
	//要保证arr不被修改
	strcpy(buf, arr);//临时拷贝
	char* str = strtok(buf, p);
	printf("%s\n", str);
	str = strtok(NULL, p);
	printf("%s\n", str);
	str = strtok(NULL, p);
	printf("%s\n", str);
	return 0;
}

 

 代码展示：（这个代码更加的方便）

#include 
int main()
{
	const char* p = "@.";
	char arr[] = "[email protected]";
	char buf[50] = { 0 };//因为字符串会被修改，所以要吧arr临时拷贝到buf里
	//要保证arr不被修改
	strcpy(buf, arr);//临时拷贝
	char* str = NULL;
	for (str = strtok(buf, p); str != NULL; str = strtok(NULL, p))
	{
		printf("%s\n", str);
	}
	return 0;
}

1.10 strerror

char * strerror ( int errnum );

返回错误码，所对应的错误信息（把错误码翻译成错误信息）

C语言中规定了一些信息

错误码—错误信息

0—No Error

1— …

2—…

当库函数使用的时候，发生错误的时候会把errno这个全局的错误变量设置为本次执行库函数产生的错误码。

errno是C语言提供的全局变量，可以直接使用，放在errno.h 这个文件，所以要引用

#include       strerror(errno);就会把错误显示出来

代码展示：

#include 
int main()
{
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%s\n", strerror(i));
	}
	return 0;
}

 

字符分类函数 

 

 上图为字符分类函数，例如：isspace,如果是空白字符，就返回非0。不是空白字符就返回0。

别的和这个用法差不多。

代码展示：

#include 
#include 
int main()
{
	printf("%d\n", isspace(' '));
	return 0;
}

 

 字符转换函数

int tolower(int c);

int toupper(int c); 

#include 
int main()
{
	char ch = 0;
	ch = getchar();
	if (islower(ch))
	{
		ch = toupper(ch);
	}
	else
	{
		ch = tolower(ch);
	}
	printf("%c\n", ch);
	return 0;
}

 大小写转换

1.11 memcpy

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

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

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

（3）如果source和destination有任何的重叠，复制的结果都是未定义的。如果destination在source的后面，就可能会导致刚改变的destination的内容，又变成了source. 就会导致重复。这种情况建议使用memmove，就不会发生。

代码展示：

#include 
int main()
{
	char arr1[] = "sjhjcd";
	char arr2[50] = { 0 };
	strcpy(arr2, arr1);//拷贝字符串

	int arr3[] = { 1, 2,3,4,5,6,7 };
	int arr4[5] = { 0 };
	memcpy(arr4, arr3, 20);//这个什么都可以拷贝，不确定拷贝什么
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr4[i]);
	}
	return 0;
}

 

C语言只要求memcpy能拷贝不重叠的的内存空间就足够了，memmove去处理那些重叠的内存空间。但是VS  的memcpy可以处理重叠的内存拷贝，也可以处理不重叠的内存拷贝。

1.12 memmove

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

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

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

memmove 也可以处理不重叠的。

1.13 memcmp

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

（1）比较从ptr1和ptr2指针开始的num个字节

（2）返回值如下：

比较的是字节，相等的话，返回0。 比较的是ASCII值。

1.14 memset 

代码展示：

#include 
int main()
{
	char arr[20] = { 0 };
	memset(arr, 'x', 10);
	return 0;
}

以字节为单位改。

二 库函数的模拟实现

2.1 模拟实现strlen

1 计数器的方法

#include 
#include 
int my_strlen(const char* str)
{
	assert(str);
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}
int main()
{
	int len = 0;
	len = my_strlen("abcdefg");//传递给my _strlen的是字符'a'的地址
	printf("%d", len);
	return 0;
}

\0 的ASCII码值是 0 ，一个表示字符串结束的标志，这是一个转义字符，整体视为一个字符，在内存中的存储为0000 0000 

字符在内存中是以ASCII码值对应的二进制的补码存在的（8位）

2.2 模拟实现strcpy

代码展示：

#include 
#include 
char* my_strcpy(char* a, const char* b)
{
	assert(a && b);
	char* ret = a;
	while (*a++ = *b++)//++的优先级大于*的优先级
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[20] = { 0 };
	char arr2[] = "hello";
	printf("%s\n", my_strcpy(arr1, arr2));//函数的链式访问
	return 0;
}

 尽量不要返回局部变量的地址（调用的那个函数，里面的局部变量，使用完就可能被销毁了，地址指向的局部变量的值，可能就变了），而不是局部变量。

2.3 模拟实现strcat

代码展示：

#include 
#include 
char* my_strcat(char* dest, const char* src)
{
	char* ret = dest;
	assert(dest && src);
	while (*dest)
	{
		dest++;
	}
	while (*dest++ = *src++)
	{
		;
	}
	return ret;
}
int main()
{
	char arr1[30] = "hello";
	char arr2[] = "world";
	my_strcat(arr1, arr2);
	printf("%s\n", arr1);
	return 0;
}

思路：（1）找到目标空间中的\0   (2)追加字符

everyting——搜索strcat——右击 打开路径

2.4 模拟实现strstr

代码展示：

#include 
#include 
char* my_strstr(const char* str1, const char* str2)
{
	assert(str1 && str2);
	if (*str2 == '\0')
	{
		return (char*)str1;//(const char* 和char*还是不同的）
	}
	//当第一个字符出现匹配，后续字母中出现不匹配的时候，字符串的地址要回到出现匹配的第一个字符，的下一个字符的地址，
	//所以尽可能不要直接用str1和str2，而是间接的使用
	const char* s1 = str1;
	const char* s2 = str2;
	const char* s3 = str1;//遇到匹配的第一个字符前一直在+1
	while (*s3)//在这个循环里，s3一直在+1，一直到s3遇到\0 ，while结束
	{
		s1 = s3;
		s2 = str2;
		while (*s1 != '\0' && *s2 != '\0' && * s1 == *s2)
		{
			s1++;
			s2++;
		}
		if (*s2 == '\0')
			return (char*)s3;
		s3++;
	}
	return NULL;
}
int main()
{
	char arr1[] = "abcdabcd";
	char arr2[] = "A";
	char* ret = my_strstr(arr1, arr2);
	if (ret == NULL)
		printf("找不到");
	else
		printf("%s\n", ret);
	return 0;
}

2.5 模拟实现strcmp

代码展示：

#include 
#include 
int my_strcmp(const char* str1, const char* str2)
{
	assert(str1 && str2);
	while (*str1 == *str2)
	{
		if (*str1 == '\0')
		{
			return 0;
		}
		str1++;
		str2++;
	}
	if (*str1 > *str2)
		return 1;
	else
		return -1;
}
int main()
{
	char arr1[] = "abc";
	char arr2[] = "abcd";
	int ret = my_strcmp(arr1, arr2);
	printf("%d", ret);
	return 0;
}

"abcd"  和"abc"比较，是1     因为，第一个字符串是d的ASCII，后一个字符串是'\0'的ascii，所以是1.

2.6 模拟实现memcpy

代码展示：
 

#include 
#include 
void* my_memcpy(void* dest, const void* src, size_t num)
{
	void* ret = dest;
	assert(dest && src);
	while (num--)//后置--，先试用，后--；
	{
		*(char*)dest = *(char*)src;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}
int main()
{
	int arr3[] = { 1, 2,3,4,5,6,7, 8, 9, 10 };
	int arr4[5] = { 0 };
	my_memcpy(arr4, arr3, 20);
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr4[i]);
	}
	return 0;
}

知识点：

（1）void* 不能进行加减，所以转换成char *进行加减。

2.7 模拟实现memmove

代码展示：

#include 
#include 
void* my_memmove(void* dest, const void* src, size_t num)//能不创建空间就不创建空间
{
	void* ret = dest;
	assert(dest && src);
	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);
		}
	}
	return ret;
}
#include 
int main()
{
	int arr3[] = { 1, 2,3,4,5,6,7, 8, 9, 10 };
	my_memmove(arr3+1, arr3, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr3[i]);
	}
	return 0;
}