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

本章重点

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

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

前言

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

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

1、字符串函数

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

//头文件

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

1.2、strcpy()—字符串拷贝

//头文件

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

简单使用介绍:

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 

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

输出:

C语言进阶---字符串+内存函数_第1张图片

1.3、strcat()—字符串追加

//头文件
char* strcat(char* destination, const char* source)
  • 源字符串必须以'\0'结束。
  • 源字符串在目标字符串有\0的地方开始追加。并不是说只会在目标字符串末尾处开始追加,只要目标字符串中间某个位置有\0,那就直接从这个位置开始追加。
  • 目标空间必须有足够的大,能容纳下源字符串的内容。
  • 目标空间必须可修改

1、简单使用介绍:

#define _CRT_SECURE_NO_WARNINGS
#include 

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

输出:

C语言进阶---字符串+内存函数_第2张图片

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

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

“helworld”。

#define _CRT_SECURE_NO_WARNINGS
#include 

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

输出:

C语言进阶---字符串+内存函数_第3张图片

2、模拟实现:

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 

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()—比较字符串大小

//头文件
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 
#include 

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 
#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[] = "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 
#include 

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

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

输出:

C语言进阶---字符串+内存函数_第4张图片

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

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

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 

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

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

这里采用调试查看:

C语言进阶---字符串+内存函数_第5张图片

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

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 

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

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语言进阶---字符串+内存函数_第6张图片

1.9、strtok()—切割字符串

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

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

    比如现在有一个字符串:“[email protected]”,假如字符@和字符.就是我们分隔符,通过这两个符号,可以将字符串切割为一段一段的。那我们就可以这样定义这个sep参数:

    const char* sep = "@.";     
    
    
  • 第一个参数指定一个字符串,它包含了0个或者多个由sep字符串中一个或者多个分隔符分隔的标记。

    这里的第一个参数就是要切割的字符串:

    char arr[] = "[email protected]";
    
    
  • 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 
    #include 
    int mian()
    {
    	const char* sep = "@.";
    	char arr[] = "[email protected]";
    	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 
#include 
int main()
{
    //创建分隔符集合
	const char* sep = "@.";
    //待分割的字符串
	char arr[] = "[email protected]";
    //创建一个临时数组
	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语言进阶---字符串+内存函数_第7张图片

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

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
int main()
{
	const char* sep = "@.";
	char arr[] = "[email protected]";
	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()

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

//头文件:
char* strerror (int errnum);

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

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

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

1、代码演示:

//在X86平台上运行

#include 
#include 

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语言进阶---字符串+内存函数_第8张图片

2、情景演示

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 

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语言进阶---字符串+内存函数_第9张图片

2、字符分类函数

函数 如果它的参数符合下列条件就返回真
iscntrl 任何控制字符
isspace 空白字符:空格’ ‘,换页’\f’,换行’\n’,回车’\r’,制表符’\t’,垂直制表符’\v’
isdigit 十进制数字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 
#include 

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

输出:

C语言进阶---字符串+内存函数_第10张图片

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

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

代码演示:

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 

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

输出:

C语言进阶---字符串+内存函数_第11张图片

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、参数介绍:

//头文件   
void * memcpy ( void * destination, const void * source, size_t num );

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

2、代码演示:

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 

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语言进阶---字符串+内存函数_第12张图片

3、模拟实现memcpy()函数

#define _CRT_SECURE_NO_WARNINGS
#include 
#include 
#include 

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函数的参数是一样的:

//头文件   
void * memmove ( void * destination, const void * source, size_t num );

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

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

C语言进阶---字符串+内存函数_第13张图片

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

#include 
#include 

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语言进阶---字符串+内存函数_第14张图片

4.3、memcmp—内存比较

//头文件   
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 
#include 

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语言进阶---字符串+内存函数_第15张图片

分析:是如何比较出来大小的呢?

首先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语言进阶---字符串+内存函数_第16张图片

4.4、memset—内存设置

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

参数说明:

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

1、代码演示:

#include 
#include 

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

输出:

C语言进阶---字符串+内存函数_第17张图片

你可能感兴趣的:(C语言,c语言)