C语言进阶---字符串+内存函数-Toy模板网

这篇具有很好参考价值的文章主要介绍了C语言进阶---字符串+内存函数。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

本章重点

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

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

前言

C语言中对字符的字符串的处理很频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。

字符串常量适用于那些对它不做修改的字符串函数。

1、字符串函数

1.1、strlen()—统计字符串长度

//头文件<string.h>

size_t strlen(const char* str);

首先传的参数需要是个指针类型的。
字符串以'\0'作为结束标志，strlen()函数返回的是在字符串中'\0'前面出现的字符个数（不包含'\0'）。
参数指向的字符串必须要以'\0'结束。
注意函数的返回值为size_t，是无符号整型的
学会strlen()函数的模拟实现。

1.2、strcpy()—字符串拷贝

//头文件<string.h>

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

源字符串必须以'\0'结束。
会将源字符串中的'\0'拷贝到目标空间。
返回值为目标字符串的首字符地址。
目标空间必须足够大，以确保能存放源字符串。
目标空间必须可变。
学会模拟实现。

简单使用介绍：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

int main()
{
	char name[20] = { 0 };
	strcpy(name, "zhangsan");
	printf("%s\n", name);
	return 0;
}

输出：

C语言进阶---字符串+内存函数,C语言,c语言

1.3、strcat()—字符串追加

//头文件<string.h>
char* strcat(char* destination, const char* source)

源字符串必须以'\0'结束。
源字符串在目标字符串有\0的地方开始追加。并不是说只会在目标字符串末尾处开始追加，只要目标字符串中间某个位置有\0，那就直接从这个位置开始追加。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改

1、简单使用介绍：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

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

输出：

C语言进阶---字符串+内存函数,C语言,c语言

2、这里说明一下：源字符串在目标字符串有\0的地方开始追加。并不是说只会在目标字符串末尾处开始追加，只要目标字符串中间某个位置有\0，那就直接从这个位置开始追加。

如下代码：“hel\0lo”，中间位置有个\0，所以在追加"world"是，就直接从"hel"初开始追加了。最后输出结果就是:

“helworld”。

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>

int main()
{
	char arr2[20] = "hel\0lo ";
	strcat(arr2, "world");
	printf("%s\n", arr2);
	return 0;
}

输出：

C语言进阶---字符串+内存函数,C语言,c语言

2、模拟实现：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>

char* my_strcat(char* dest, const char* source)
{
	char* ret = dest;
	assert(dest && source);
	//1、找到目标字符串的\0。
	while (*dest != '\0')
	{
		dest++;
	}
    //2、拷贝
	while (*dest++ = *source++)
	{
		;
	}
	return ret;
}

int main()
{
	char arr1[20] = "hello ";
	my_strcat(arr1, "world");
	printf("%s\n", arr1);
	return 0;
}

那能不能实现字符串自己给自己追加？如下：

答案：是不能的。

int main()
{
	char arr1[20] = "hello ";
	my_strcat(arr1, arr1);             //如何实现这样的效果呢？
	printf("%s\n", arr1);
	return 0;
}

1.4、strcmp()—比较字符串大小

//头文件<string.h>
int strcmp(const char* str1, const char* str2);

返回值：
- 第一个字符串<第二个字符串，就返回小于0的数字
- 第一个字符串=第二个字符串，就返回0
- 第一个字符串>第二个字符串，就返回大于0的数字

那具体是怎么比较的呢？是依次比较各个字符串中字符的ASCII值。

比如：首先arr1中的字符’a’和arr2中的字符’a’进行比较，发现ASCII一样，然后再比较字符’b’…

之后当比较到arr1中的字符’d’和arr2中的字符’f’是，发现arr2中的’f’的ASCII值比arr1中的’d’的ASCII值大。

所以最终结果为arr2大。

char arr1[] = "abcd";
char arr2[] = "abcf";

1、简单使用：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

int main()
{
	char arr1[] = "abcd";
	char arr2[] = "abcf";
	int ret = strcmp(arr1, arr2);    //arr1小于arr2
	if (ret < 0)
		printf("<\n");
	else if (ret == 0)
		printf("=\n");
	else
		printf(">\n");
	return 0;
}

输出：

C语言进阶---字符串+内存函数,C语言,c语言

2、模拟实现：

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

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[] = "abcd";
	char arr2[] = "abcf";
	int ret = my_strcmp(arr1, arr2);
	if (ret < 0)
		printf("<\n");
	else if (ret == 0)
		printf("=\n");
	else
		printf(">\n");
	return 0;
}


//判断>或者<的返回值还可以在优化：
//将下面一段代码替换为最后一行优化的代码
if (*str1 > *str2)
		return 1;
	else
		return -1;

//替换这个优化的代码
return *str1 - *str2;

关于以上库函数不安全的说明

上面所说到了库函数，其实是相对不安全的，比如：

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

int main()
{
	char arr1[] = "abcd";
	char arr2[] = "abcdfr";
	//arr2的字符长度比arr1的字符长度长，当让arr2拷贝到arr1时，arr1数组会放不下，
	//放不下编译器也会放，那就呆滞了越界访问，以至于改变了其它内存中的数据，这是相当危险的。
	strcpy(arr1, arr2);   
	return 0;
}

那这个时候，就应用诞生了相对来说安全一点的库函数：长度受限制的的字符串函数。

长度受限制的字符串函数是什么意思呢？下面介绍：

1.5、strncpy()–长度受限制拷贝

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

多个参数：num。这个参数就是限制长度的参数，比如说让arr2的字符串拷贝到arr1中去，但是只允许拷贝3个字节的字符:

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

int main()
{
	char arr1[] = "aaaaa";
	char arr2[] = "bbbbb";
	//让arr2的数据拷贝到arr1中去，但是只拷贝3个字节。
	strncpy(arr1, arr2,3);   
	printf("%s\n", arr1);
	return 0;
}

输出：

C语言进阶---字符串+内存函数,C语言,c语言

可以看到输出结果：只会将arr2中的前3个字符拷贝到arr1中，arr1前3个也字符会改变，并且后面的字符不会改变。

1.6、strncat()—长度受限制追加

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

int main()
{
	char arr1[20] = "hello\0xxxxxx";
	char arr2[] = "world";
	strncat(arr1, arr2, 3);
	printf("%s\n", arr1);
	return 0;
}

输出：这里有个点要注意以下：在使用strncat()时，在追加完毕后，会自动在目标字符串末尾添加一个\0表示一个字符的结束。

这里采用调试查看：

C语言进阶---字符串+内存函数,C语言,c语言

1.7、strncmp()—长度受限制比较

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abc";
	strncmp(arr1, arr2, 3);   //只比较3个字符，结果应该为相等。
	return 0;
}

1.8、strstr()—查找子串

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

参数说明：

str1是母字符串的地址
str2是子串的地址

比如现在有两个字符串：

char arr1[] = "abcdef";
char arr2[] = "cde"
strstr(arr1,arr2);

需要在arr1（母字符串）中寻找有没有arr2（子串）的内容。首先arr2中的字符串内容为：“cde”，而arr1中的字符串：“abcdef”，正好全部包含"cde"。那么此时strstr()函数会返回arr1中包含子串的首字符地址。也就是会返回arr1中字符c的地址。那如果我们在以%s打印时，就会将arr1的"cdef"的值全部打印出来，因为从起始位置’c’到’\0’结束，就是"cdef"。

所以strstr()函数的返回值是个char*类型的。

如果没有查找到字串，就会返回一个NULL指针。

1、使用演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "cde";
	char* ret = strstr(arr1, arr2);
	if (ret == NULL)
	{
		printf("没有找到\n");
	}
	else
	{
		printf("%s\n", ret);
	}
	return 0;
}

输出：

C语言进阶---字符串+内存函数,C语言,c语言

1.9、strtok()—切割字符串

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

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

比如现在有一个字符串：“zhengbo@helloworld.com”，假如字符@和字符.就是我们分隔符，通过这两个符号，可以将字符串切割为一段一段的。那我们就可以这样定义这个sep参数：
```
const char* sep = "@.";     
```
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分隔的标记。

这里的第一个参数就是要切割的字符串：
```
char arr[] = "zhengbo@helloworld.com";
```
strtok函数找到了str中的下一个标记，并将其用\0结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容没那个，并且可修改。）

strtok函数找到了str中的下一个标记这句话的意思就是说，strtok找到了@分隔符，就会把@分隔符变为'\0'，那arr数组就会变成如下的样子：
```
char arr[] = "zhengbo\0helloworld.com";
```
然后返回一个指向这个标记的指针，就是把分隔好的字符串：“zhengbo\0”，通过返回字符'z'的地址，作为指针返回过去。

但是这样我们会发现一个问题：就是会把arr数组里面的内容给修改。那如果下面程序还需要使用arr数组呢？那情况就不对。所以说我们先应该使用strcmp()函数把arr数组给临时拷贝一份给另外一个数组，然后把临时拷贝的数组交给strtok来进行操作，那这样既能提取出来分隔的字符串，又能不对原数组arr进行修改。具体实现如下代码：
```
#include <stdio.h>
#include <string.h>
int mian()
{
	const char* sep = "@.";
	char arr[] = "zhengbo@helloworld.com";
	char cp[30] = { 0 };
	strcmp(cp,arr);     //临时拷贝一份
	strtok(cp, sep);    //对临时拷贝的数组进行分隔
	return 0;
}
```
strtok函数的第一个参数不为NULL，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。

这个是说，我们在首次使用strtok函数时，需要传第一个参数，因为第一个参数里面保存了分隔符的地址，有了一个参数后，函数将找到str中第一个标记，也就是说找到了@标记（分隔符），然后返回首字符z的地址，作为函数返回值，然后保存下来。
strtok函数的第一个参数为NULL，函数将在同一个字符串中被保存的位置开始，查找下一个标记。

到这一步，再次调用strtok函数，需要找第二个，第三个，第四个分割符的时候就不需要传第一个参数了，所以到这个地方我们就能明白，只有在找第一个分隔符的时候才传第一个参数。好，那问题又来了：那不传第一个参数，如何找到，下一个需要分割为字符串的首字符地址呢？原因是这样的：其实在找到第一个分隔符之后，NULL指针表示一种状态，NULL指针会记录着上一个分割后的起始位置，也就已经记着了第一个分隔符后面的字符地址了。然后在根据sep中记录的分隔符，分割出一段字符串。
如果字符串中不存在更多的标记，则返回NULL指针。

到这一步，是说，在真个arr数组里面没找到分隔符，那就直接strtok函数返回NULL指针。

1、效果演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
int main()
{
    //创建分隔符集合
	const char* sep = "@.";
    //待分割的字符串
	char arr[] = "zhengbo@helloworld.com";
    //创建一个临时数组
	char cp[30] = { 0 };
	//拷贝一份临时数据
	strcpy(cp,arr);
	//切割出zhengbo@，并把@换为\0了，且把z字符的地址，返回给了ret。
	char* ret = strtok(cp, sep);    
	//打印出：zhengbo
	printf("%s\n", ret);
	
    //打印helloworld，这里的NULL指针表示一种状态，NULL指针记录了'h'的地址
	ret = strtok(NULL, sep);
	printf("%s\n", ret);
	
    //打印com，这里NULL指针记录了'c'的地址
	ret = strtok(NULL, sep);
	printf("%s\n", ret);
	return 0;
}

输出：

C语言进阶---字符串+内存函数,C语言,c语言

2、优化：上面的代码分割一个字符串就需要打印一次，其实这里可以写个for循环，来优化下代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
int main()
{
	const char* sep = "@.";
	char arr[] = "zhengbo@helloworld.com";
	char cp[30] = { 0 };
	//拷贝一份临时数据
	strcpy(cp,arr);
	//切割出zhengbo@，并把@换为\0了，且把z字符的地址，返回给了ret。
	char* ret = NULL;
    //优化部分
	for (ret = strtok(cp, sep); ret != NULL; ret = strtok(NULL, sep))
	{
		printf("%s\n", ret);
	}
	return 0;
}

1.10、strerror()

返回错误码，所对应的错误信息。

//头文件：<errno.h>
char* strerror (int errnum);

在C语言中，库函数在执行失败的时候，都会设置错误码。

虽说设置的都有错误码，但是我们怎么样才能知道错误码所对应的错误信息呢？

这个时候strerror()函数就起作用了。只需要把错误码传参进去，这个函数就会返回错误码所对应错误信息字符串的首字符地址。

1、代码演示：

//在X86平台上运行

#include <stdio.h>
#include <errno.h>

int main()
{
	printf("%s\n", strerror(0));
	printf("%s\n", strerror(1));
	printf("%s\n", strerror(2));
	printf("%s\n", strerror(3));
	return 0;
}

输出：

C语言进阶---字符串+内存函数,C语言,c语言

2、情景演示

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <errno.h>

int main()
{
	//使用fopen()表示打开一个文件，并且r表示以只读的方式进行。
	//如果打开成功会返回一个指针，如果打开失败会返回NULL指针。
	//现在本地没有test.txt文件，所以会打开文件失败，返回NULL指针。
	FILE* pf = fopen("test.txt", "r");
	if (pf == NULL)
	{
		//errno是C语言中设置一个全局变量，用来专门存放错误码的。
		printf("%s\n", strerror(errno));
        return 1;
	}
	return 0;
}

输出：

C语言进阶---字符串+内存函数,C语言,c语言

2、字符分类函数

函数	如果它的参数符合下列条件就返回真
iscntrl	任何控制字符
isspace <ctype.h>	空白字符：空格’ ‘，换页’\f’，换行’\n’，回车’\r’，制表符’\t’，垂直制表符’\v’
isdigit <ctype.h>	十进制数字0~9
isxdigit	十六进制数字，包括所有十进制数字，小写字母a_{f，大写字母A}F
islower	小写字母a-z
isupper	大写字母A-Z
isalpha	字母a_z或AZ
isalnum	字母或数字，a_z、AZ、0~9
ispunct	标点符号，任何不属于数字或字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符

3、字符转换函数

字符转换：

1、tolower()-------------将大写字母转为小写

int tolower(int c);     //将大写字母转为小写，如果传参数表示大写字母，给什么值，输出什么值。

代码演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <ctype.h>

int main()
{
	printf("%c\n", tolower('A'));
	return 0;
}

输出：

C语言进阶---字符串+内存函数,C语言,c语言

2、toupper()----------------将小写字母转为大写

int toupper(int c);     //将小写字母转为大写，如果传参数表示小写字母，给什么值，输出什么值。

代码演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <ctype.h>

int main()
{
	printf("%c\n", toupper('g'));
	return 0;
}

输出：

C语言进阶---字符串+内存函数,C语言,c语言

4、内存操作函数

4.1、memcpy函数—内存拷贝（不能用来拷贝重叠内存）

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

函数memcpy从source的位置开始向后复制num个__字节__的数据到destination的内存位置。
这个函数在遇到’\0’的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。

上面讲到字符函数也有两个拷贝：strcpy、strncpy。

但是这两个库函数都是指针字符串进行拷贝的。

那现在有两个整型数组，如何拷贝呢？

比如：

int arr1[] = {1,2,3,4,5,6};
int arr2[10] = {0};

这个时候就需要使用memcpy()库函数了。

在介绍这个库函数前，先来思考一下这个库函数诞生的原因：如果需要拷贝字符类型的数据用到了strcpy、strncpy函数，那如果需要拷贝整型数据的呢？需要产生一个专用于整型拷贝的库函数吗？如果需要拷贝浮点型呢？如果需要拷贝结构体呢？不可能说都会产生一个对应的拷贝库函数。

而是说直接用一个memcpy()函数，这个函数是直接对内存进行操作的，它拷贝的是内存块里面的数据。而无论是字符还是整形，或者是浮点型，再或者是结构体。它们的数据都是存放在内存中的。所以说可以直接用memcpy()函数进行统一拷贝操作。

1、参数介绍：

//头文件   <string.h>
void * memcpy ( void * destination, const void * source, size_t num );

destination目标地址
source 源地址
参数num的单位是字节。

2、代码演示：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7 };
	int arr2[10] = { 0 };
	//因为一个整型是4个字节，arr1里面有7个整型数字，所以是28个字节，
	//memcpy的三个参数num的单位是字节，所以应传参28
    //将arr1的数据拷贝到arr2中
	memcpy(arr2, arr1, 28);
	return 0;
}

调试查看：

C语言进阶---字符串+内存函数,C语言,c语言

3、模拟实现memcpy()函数

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#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;
		dest = (char*)dest + 1;
		src = (char*)src + 1;
	}
	return ret;
}

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7 };
	int arr2[10] = { 0 };
	//因为一个整型是4个字节，arr1里面有7个整型数字，所以是28个字节，
	//memcpy的三个参数num的单位是字节，所以应传参28
	my_memcpy(arr2, arr1, 28);
	return 0;
}

4.2、memmove函数------内存拷贝（可以用来重叠内存之间的拷贝）

memcpy函数和memmove函数基本功能大致一样，但是memmove有个比memcpy强大的小功能：

1、memcpy函数是不能用来处理重叠的内存之间的数据拷贝。

2、memmove函数是可以处理重叠内存之间的数据拷贝的。

3、 memcpy只是memmove的一个子集。

memmove函数的参数和memmove函数的参数是一样的：

//头文件   <string.h>
void * memmove ( void * destination, const void * source, size_t num );

既然参数一样，那两个函数的用法也是一样的。

假如如下是数组arr1重叠部分：

C语言进阶---字符串+内存函数,C语言,c语言

下面来实现内存重叠的代码演示：

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

int main()
{
	int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
	memmove(arr1, arr1 + 2, 20);
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr1[i]);
	}
	return 0;
}

输出：

C语言进阶---字符串+内存函数,C语言,c语言

4.3、memcmp—内存比较

//头文件   <string.h>
int memcmp ( const void * ptr1, const void * ptr2, size_t num );

num参数是字节。
比较从ptr1和ptr2指针开始的num个__字节__。
返回值如下：
- ptr1内存块中存储的数据比ptr1内存块中存储的数据大，就返回>0的值
- ptr1内存块中存储的数据比ptr1内存块中存储的数据小，就返回<0的值
- 如果将所指定的num字节全部比较完毕后，还是一样的大小，会返回0.

1、代码演示：

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

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 1,3,2 };
	//这里num为12，表示比较12个字节的内容，一个int占用4个字节，所以一共比较3个数字。
	int ret = memcmp(arr1, arr2, 12);
	printf("%d\n", ret);
	return 0;
}

输出：

C语言进阶---字符串+内存函数,C语言,c语言

分析：是如何比较出来大小的呢？

首先arr1中的数字在内存中是这样存储的：
01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00

然后arr2中的数字在内存中是这样存储的：

01 00 00 00 03 00 00 00 02 00 00 00

因为我们指定了只比较12个字节的数据，所以两个数组开始从头比较，直到比较到第五个字节（如下图）：

arr1的数据是02，arr2的数据是03。这样一来比较大小就有了结果。是arr2大。所以返回-1<0的值。

C语言进阶---字符串+内存函数,C语言,c语言

4.4、memset—内存设置

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

参数说明：

ptr：需要填充的内存块的地址。
value：要被填充的内容，（看着是int类型的，其实可以传char类型的数据，因为字符在内存中存储也是按照ASCII值存储的）。
num：要被填充多少个字节。

1、代码演示：

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

int main()
{
	char arr[] = "hello bbo";
	//表示，从整个字符数组首字符开始，一直填充5个'x'字符。
	memset(arr, 'x', 5);
	printf("%s\n", arr);
	return 0;
}

输出：

C语言进阶---字符串+内存函数,C语言,c语言文章来源地址https://www.toymoban.com/news/detail-522008.html