本章重点

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

• 求字符串长度
  • 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;
}

输出：

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;
}

输出：

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;
}

输出：

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;
}

输出：

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;
}

输出：

可以看到输出结果：只会将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表示一个字符的结束。

这里采用调试查看：

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;
}

输出：

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;
}

输出：

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;
}

输出：

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;
}

输出：

2、字符分类函数

函数	如果它的参数符合下列条件就返回真
iscntrl	任何控制字符
isspace <ctype.h>	空白字符：空格’ ‘，换页’\f’，换行’\n’，回车’\r’，制表符’\t’，垂直制表符’\v’
isdigit <ctype.h>	十进制数字0~9
isxdigit	十六进制数字，包括所有十进制数字，小写字母af，大写字母AF
islower	小写字母a-z
isupper	大写字母A-Z
isalpha	字母az或AZ
isalnum	字母或数字，az、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;
}

输出：

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;
}

输出：

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;
}

调试查看：

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重叠部分：

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

#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;
}

输出：

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;
}

输出：

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

首先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的值。

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;
}

输出：